66681 2011-08-22 10:20:44 -0700 Need API for getting surrounding text from webkit in chromium 2013-04-11 15:06:20 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 penghuang webkit-unassigned abarth ap bryeung fishd hbono morrita rniwa schenney tony webkit.review.bot oldest_to_newest 454660 0 penghuang 2011-08-22 10:20:44 -0700 The API is for getting surrounding text from webkit in chromium. Some input methods may generate different results depend on the text around input cursor. 454661 1 104692 penghuang 2011-08-22 10:22:18 -0700 Created attachment 104692 Patch 455312 2 104692 morrita 2011-08-23 04:32:09 -0700 Comment on attachment 104692 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=104692&action=review > Source/WebKit/chromium/public/WebWidget.h:154 > + virtual bool surrounding(WebString& text, size_t& cursor, size_t& anchor) { return false; } You can return WebSize. See (Source/WebKit/public/WebSize.h) > Source/WebKit/chromium/src/WebViewImpl.cpp:1512 > +bool WebViewImpl::surrounding(WebString& text, size_t& cursor, size_t& anchor) It's sad to have this logic in WebKit layer. If we have this in WebCore and make it available from LayoutTestcontroller or window.internals, It can be testable and also would be helpful for other ports. 455314 3 morrita 2011-08-23 04:33:30 -0700 CC-ed rniwa to see editing API usage, fishd for the Chromium API addition. 455419 4 104692 rniwa 2011-08-23 08:33:44 -0700 Comment on attachment 104692 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=104692&action=review >> Source/WebKit/chromium/public/WebWidget.h:154 >> + virtual bool surrounding(WebString& text, size_t& cursor, size_t& anchor) { return false; } > > You can return WebSize. See (Source/WebKit/public/WebSize.h) The standard term used is focus and anchor. "cursor" usually refers to mouse cursor, and it's confusing. Alos, Why isn't this function const? Also the last time I checked, Chromium's coding style guide forbid mutable reference and instead forces pass by pointer. > Source/WebKit/chromium/src/WebViewImpl.cpp:1530 > + Element* scope = selectionRoot ? selectionRoot : frame->document()->documentElement(); Wait a minute, if rootEditableElement can be null, then element->innerText() would have blown up by null-pointer access, no? r- because of this. Also, this line appears to be much longer than 80 characters, yet chromium coding guideline mandates the column length to be at most 80 characters. > Source/WebKit/chromium/src/WebViewImpl.cpp:1539 > + anchor = TextIterator::rangeLength(testRange.get()); > + > + ExceptionCode ec; > + testRange->setEnd(selection->extent().containerNode(), selection->extent().offsetInContainerNode(), ec); > + cursor = TextIterator::rangeLength(testRange.get()); You should call TextIterator::locationAndLengthFromRange instead. 455443 5 104692 penghuang 2011-08-23 09:24:59 -0700 Comment on attachment 104692 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=104692&action=review >>> Source/WebKit/chromium/public/WebWidget.h:154 >>> + virtual bool surrounding(WebString& text, size_t& cursor, size_t& anchor) { return false; } >> >> You can return WebSize. See (Source/WebKit/public/WebSize.h) > > The standard term used is focus and anchor. "cursor" usually refers to mouse cursor, and it's confusing. Alos, Why isn't this function const? Also the last time I checked, Chromium's coding style guide forbid mutable reference and instead forces pass by pointer. struct WebSize { int width; int height; ...} cursor, and anchor are indexes in plain text. I think it is different with WebSize. I will change the names. For coding style, I think the code is in webkit, probably it is better to follow webkit coding guideline? And I also find some functions use mutable reference in this header file. I am confused. >> Source/WebKit/chromium/src/WebViewImpl.cpp:1512 >> +bool WebViewImpl::surrounding(WebString& text, size_t& cursor, size_t& anchor) > > It's sad to have this logic in WebKit layer. > If we have this in WebCore and make it available from LayoutTestcontroller or window.internals, It can be testable > and also would be helpful for other ports. Could you give more detail information? So I could look into it. >> Source/WebKit/chromium/src/WebViewImpl.cpp:1530 > > Wait a minute, if rootEditableElement can be null, then element->innerText() would have blown up by null-pointer access, no? r- because of this. > > Also, this line appears to be much longer than 80 characters, yet chromium coding guideline mandates the column length to be at most 80 characters. I will fixed rootEditableElement issue. Probably those code is in webkit repo. It should follow webkit coding guideline. For example indent is 2 spaces in chrome, but here is 4 spaces. 455464 6 rniwa 2011-08-23 10:13:21 -0700 (In reply to comment #5) > For coding style, I think the code is in webkit, probably it is better to follow webkit coding guideline? And I also find some functions use mutable reference in this header file. I am confused. Mn... it appears to me WebViewImpl.cpp follows Chromium coding convention but I can be wrong. Darin probably knows what we should be doing here. > >> Source/WebKit/chromium/src/WebViewImpl.cpp:1512 > >> +bool WebViewImpl::surrounding(WebString& text, size_t& cursor, size_t& anchor) > > > > It's sad to have this logic in WebKit layer. > > If we have this in WebCore and make it available from LayoutTestcontroller or window.internals, It can be testable > > and also would be helpful for other ports. > > Could you give more detail information? So I could look into it. The logic to extract surrounding text exists in many WebKit ports. I'm actually surprised that we don't already have a logic to do this for IME. > Probably those code is in webkit repo. It should follow webkit coding guideline. For example indent is 2 spaces in chrome, but here is 4 spaces. That's true. But most of lines in that file appear to fit in 80-characters. So I'm a bit confused here as well. 455468 7 rniwa 2011-08-23 10:14:31 -0700 +ap since he has recently done some nice refactoring in this area. Maybe we want to do the same for surrounding text. I've seen so many ports implementing this function incorrectly :( 455475 8 ap 2011-08-23 10:23:18 -0700 Doesn't Chromium already implement attributedSubstringForProposedRange:proposedRange: on Mac? That's how input methods normally get surrounding text, so it's unclear why any new code is needed. 455484 9 104692 fishd 2011-08-23 10:30:41 -0700 Comment on attachment 104692 Patch by the way, the method name "surrounding" is perhaps a bit too vague. maybe it should be named getSurroundingText? 455488 10 104692 tony 2011-08-23 10:33:18 -0700 Comment on attachment 104692 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=104692&action=review Since the file is in the webkit repo, we should follow the webkit coding style. Fitting into 80 cols does not violate the webkit coding style. This file has a mix of styles, but we should try to write new code using webkit style. > Source/WebKit/chromium/ChangeLog:4 > + Add API for getting surrounding text from webkit in chromium > + https://bugs.webkit.org/show_bug.cgi?id=66681 Please explain why this you need this in the changelog (copying the text from comment #0 would be sufficient). > Source/WebKit/chromium/src/WebViewImpl.cpp:1541 > + // TODO truncate the text into reansonable size WebKit style uses FIXME rather than TODO. 455942 11 morrita 2011-08-23 19:25:03 -0700 > struct WebSize { > int width; > int height; > ...} > > cursor, and anchor are indexes in plain text. I think it is different with WebSize. That's true. My feedback there was pointless. > >> Source/WebKit/chromium/src/WebViewImpl.cpp:1512 > >> +bool WebViewImpl::surrounding(WebString& text, size_t& cursor, size_t& anchor) > > > > It's sad to have this logic in WebKit layer. > > If we have this in WebCore and make it available from LayoutTestcontroller or window.internals, It can be testable > > and also would be helpful for other ports. > > Could you give more detail information? So I could look into it. > These code can be located somewhere under WebCore/, then it could be testable using Webkit testing infrastructure. FrameSelection looks a good candidate. 456302 12 penghuang 2011-08-24 12:22:47 -0700 (In reply to comment #4) > (From update of attachment 104692 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=104692&action=review > > > Source/WebKit/chromium/src/WebViewImpl.cpp:1539 > > + anchor = TextIterator::rangeLength(testRange.get()); > > + > > + ExceptionCode ec; > > + testRange->setEnd(selection->extent().containerNode(), selection->extent().offsetInContainerNode(), ec); > > + cursor = TextIterator::rangeLength(testRange.get()); > > You should call TextIterator::locationAndLengthFromRange instead. In this case, cursor and anchor is not a range object, and the order of cursor and anchor is not same (depends on the direction of the selection). So I think using TextIterator::rangeLength() directly is simpler and efficient. What do you think? 458013 13 104692 rniwa 2011-08-28 09:50:26 -0700 Comment on attachment 104692 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=104692&action=review >>> Source/WebKit/chromium/src/WebViewImpl.cpp:1539 >>> + cursor = TextIterator::rangeLength(testRange.get()); >> >> You should call TextIterator::locationAndLengthFromRange instead. > > In this case, cursor and anchor is not a range object, and the order of cursor and anchor is not same (depends on the direction of the selection). So I think using TextIterator::rangeLength() directly is simpler and efficient. What do you think? That sounds like an anti-pattern to me. Why do we need this API? What is it used for? 458038 14 penghuang 2011-08-28 18:16:49 -0700 (In reply to comment #13) > > In this case, cursor and anchor is not a range object, and the order of cursor and anchor is not same (depends on the direction of the selection). So I think using TextIterator::rangeLength() directly is simpler and efficient. What do you think? > > That sounds like an anti-pattern to me. Why do we need this API? What is it used for? Some input method can generate different input depends on text before or after input cursor. And some input method can also reconvert committed text or selected text to some others. For example, the mozc input method can also reconvert committed text input Hiragana or Katakana, and etc. This API is for getting the surrounding text and anchor, cursor position in surrounding text. 459144 15 105686 penghuang 2011-08-30 13:35:58 -0700 Created attachment 105686 Patch 459160 16 105686 rniwa 2011-08-30 13:49:09 -0700 Comment on attachment 105686 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=105686&action=review > Source/WebCore/editing/FrameSelection.cpp:1887 > +bool FrameSelection::getSurroundingText(String& text, size_t& focus, size_t& anchor) const It seems like the function name should reflect the fact it only obtains text in the content editable area. Also, I'd expect the return value of a function named get...Text to be a string. > Source/WebCore/editing/FrameSelection.cpp:1893 > + if (!isContentEditable()) > + return false; > + > + Element* element = rootEditableElement(); > + if (!element) This check is redundant. If there's no root editable element, then it's surely not editable. > Source/WebCore/editing/FrameSelection.cpp:1900 > + RefPtr<Range> testRange = Range::create( > + element->document(), element, 0, > + base().containerNode(), base().offsetInContainerNode()); You should call computeOffsetInContainerNode instead. Otherwise this will hit an assertion. r- because of this. > Source/WebCore/editing/FrameSelection.cpp:1905 > + testRange->setEnd(extent().containerNode(), > + extent().offsetInContainerNode(), ec); Why don't you just do setEnd(extent(), ec) ? > Source/WebCore/editing/FrameSelection.cpp:1908 > + // FIXME truncate the text into reansonable size Nit: need a colon after FIXME. > Source/WebCore/editing/FrameSelection.h:246 > + bool getSurroundingText(String&, size_t&, size_t&) const; You probably need to say what these size_t's are. > Source/WebKit/chromium/src/WebViewImpl.cpp:1513 > + String tmp; Let's not use such an ambiguous shorthanded name. We can rename text to webText or passedText. Alternatively we can rename tmp to coreText. 459171 17 ap 2011-08-30 13:56:23 -0700 As mentioned in comment 8, WebCore (and even WebKit/chromium) should already have all the necessary functionality. Why is this code being added? 459208 18 penghuang 2011-08-30 14:36:07 -0700 (In reply to comment #17) > As mentioned in comment 8, WebCore (and even WebKit/chromium) should already have all the necessary functionality. Why is this code being added? Sorry. I don't know which functions were you mentioned. Could you please give more detail? Thanks. Just to clarify. We need API in chromium (all platforms). It can get the plain text surrounding the current input cursor, and the cursor index in the plain text. If selection exists, we want to get the index of the anchor as well. 459227 19 rniwa 2011-08-30 14:45:01 -0700 Mn... now that I think about it, you should be able to use locationAndLengthFromRange and then ask FrameSelection::baseIsFirst() to determine which one is anchor and focus. 459276 20 ap 2011-08-30 15:39:22 -0700 What I'm saying is that this functionality exists in input methods on Mac. They work through NSTextInputClient protocol, which is implemented in WebKit. You can take a look at the implementation. 459452 21 fishd 2011-08-30 22:40:10 -0700 Yes, indeed we do implement something like this on the Mac. See WebKit::WebSubstringUtil::attributedSubstringInRange(...) in WebKit/chromium/public/mac/WebSubstringUtil.h. It appears to be implemented as a forked copy of a similar function defined in WebKit/mac/Misc/WebNSAttributedStringExtras.mm. Forking :-( Obviously, that does not work on non-Mac platforms. It is not so clear to me that it is exactly analogous to what we want in this case, but I haven't studied it very closely. Thanks for the tip! 459769 22 penghuang 2011-08-31 11:30:16 -0700 (In reply to comment #20) > What I'm saying is that this functionality exists in input methods on Mac. They work through NSTextInputClient protocol, which is implemented in WebKit. You can take a look at the implementation. I checked related functions. They are for Mac platform only. And the interfaces are different with Linux and Windows. On Linux, IME does not specify a rang for getting the surrounding text. The application need report the cursor and selection with surrounding plain text. So we need implement the new API. I will make WebSubstringUtil::attributedSubstringInRange() as a reference. Thanks. 459783 23 penghuang 2011-08-31 11:41:13 -0700 (In reply to comment #16) > (From update of attachment 105686 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=105686&action=review > > > Source/WebCore/editing/FrameSelection.cpp:1887 > > +bool FrameSelection::getSurroundingText(String& text, size_t& focus, size_t& anchor) const > > It seems like the function name should reflect the fact it only obtains text in the content editable area. Also, I'd expect the return value of a function named get...Text to be a string. How about getSurrounding() or getSurroundingTextAndSelection()? Or do you have some better suggestions? 459788 24 rniwa 2011-08-31 11:43:30 -0700 (In reply to comment #23) > How about getSurrounding() or getSurroundingTextAndSelection()? Or do you have some better suggestions? Neither of those names signify the fact this function only works in editable region. 459795 25 penghuang 2011-08-31 11:54:40 -0700 (In reply to comment #24) > (In reply to comment #23) > > How about getSurrounding() or getSurroundingTextAndSelection()? Or do you have some better suggestions? > > Neither of those names signify the fact this function only works in editable region. getSurroundingIfEditable(), getSurroundingAndSelectionIfEditable(), getInputSurrounding() or getInputSurroundingAndSelection(). ? I can not get better names. BTW, I prefer without AndSelection suffix personally. 459797 26 rniwa 2011-08-31 11:57:23 -0700 (In reply to comment #25) > getSurroundingIfEditable(), getSurroundingAndSelectionIfEditable(), getInputSurrounding() or getInputSurroundingAndSelection(). > > ? I can not get better names. BTW, I prefer without AndSelection suffix personally. I'd call it textInEditableElementWithSelectionAnchorAndFocus or textInEditableElementWithSelection. 459798 27 rniwa 2011-08-31 11:57:50 -0700 (In reply to comment #26) > (In reply to comment #25) > > getSurroundingIfEditable(), getSurroundingAndSelectionIfEditable(), getInputSurrounding() or getInputSurroundingAndSelection(). > > > > ? I can not get better names. BTW, I prefer without AndSelection suffix personally. > > I'd call it textInEditableElementWithSelectionAnchorAndFocus or textInEditableElementWithSelection. I mean textInRootEditableElementWithSelectionAnchorAndFocus or textInRootEditableElementWithSelection 459810 28 penghuang 2011-08-31 12:03:43 -0700 (In reply to comment #27) > I mean textInRootEditableElementWithSelectionAnchorAndFocus or textInRootEditableElementWithSelection textInRootEditableElementWithSelection looks better. I will use it. Thanks. 459858 29 penghuang 2011-08-31 13:31:53 -0700 (In reply to comment #19) > Mn... now that I think about it, you should be able to use locationAndLengthFromRange and then ask FrameSelection::baseIsFirst() to determine which one is anchor and focus. I think locationAndLengthFromRange() does not have a clear definition. What is the origin position of the location? It may be in the rootEditableElement of the range or in whole document. The scope is unclear. 459861 30 rniwa 2011-08-31 13:33:55 -0700 (In reply to comment #29) > (In reply to comment #19) > > Mn... now that I think about it, you should be able to use locationAndLengthFromRange and then ask FrameSelection::baseIsFirst() to determine which one is anchor and focus. > > I think locationAndLengthFromRange() does not have a clear definition. What is the origin position of the location? It may be in the rootEditableElement of the range or in whole document. The scope is unclear. Then we should address that issue rather than duplicating code. 459862 31 ap 2011-08-31 13:34:19 -0700 > I checked related functions. They are for Mac platform only. It's obvious that NSTextInputClient is a Mac specific interface. It's implementation is a thin wrapper around WebCore. What I'm saying is that it's very unlikely that you genuinely need to make any WebCore changes. 459894 32 rniwa 2011-08-31 14:00:37 -0700 Peng, we can talk about how to proceed with this bug on IRC if you'd like. Alexey and I are known as ap and rniwa on #webkit respectively. 459938 33 penghuang 2011-08-31 14:41:23 -0700 After discussion on IRC, we decided to put code in WebKit layer and use locationAndLengthFromRange. 460797 34 106034 penghuang 2011-09-01 14:49:42 -0700 Created attachment 106034 Patch 460806 35 106034 rniwa 2011-09-01 14:58:10 -0700 Comment on attachment 106034 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=106034&action=review > Source/WebKit/chromium/ChangeLog:4 > + Add API for getting surrounding text and selection range > + from webkit in chromium. Why is this line awkwardly wrapped in the middle of a sentence? > Source/WebKit/chromium/ChangeLog:8 > + You need to describe what kind of changes you're making. > Source/WebKit/chromium/src/WebViewImpl.cpp:1533 > + if (selection->base().containerNode() == selection->extent().containerNode()) { > + // In most case focus and anchor are in the same element. We get the > + // text from this element. > + Node* node = selection->base().containerNode(); > + if (!node || !node->isElementNode()) > + return false; > + Element* element = static_cast<Element*>(selection->base().containerNode()); > + text = element->innerText(); > + focus = selection->base().computeOffsetInContainerNode(); > + anchor = selection->extent().computeOffsetInContainerNode(); > + return true; > + } Let's not do this. It's anti-pattern, and IME probably needs more context than what it fits in one element. > Source/WebKit/chromium/src/WebViewImpl.cpp:1538 > + // If focus and anchor are in different nodes, we will get the text from > + // the root editable element. > + // FIXME: Find the smaller scope which can conver the focus and anchor > + // instead of the root editable element. This is a completely tangential issue that's present throughout WebKit's code that came out of the discussion ap & I had. I don't think you should include FIXME like this here. > Source/WebKit/chromium/src/WebViewImpl.cpp:1556 > + Element* element = selection->rootEditableElement(); You should do this where you check whether selection is in a contenteditable region or not. 460845 36 106046 penghuang 2011-09-01 15:22:07 -0700 Created attachment 106046 Patch 460847 37 106046 rniwa 2011-09-01 15:27:25 -0700 Comment on attachment 106046 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=106046&action=review r- due to various nits. > Source/WebKit/chromium/ChangeLog:7 > + Again, please add description here. > Source/WebKit/chromium/public/WebWidget.h:157 > + virtual bool surroundingTextWithSelection( > + WebString& text, > + size_t& focus, > + size_t& anchor) const { return false; } I'd put everything in one line. Also, "text" doesn't add any value here so you can omit. > Source/WebKit/chromium/src/WebViewImpl.cpp:1522 > + const FrameSelection* selection = frame->selection(); > + if (!selection->isContentEditable()) > + return false; > + > + Element* element = selection->rootEditableElement(); I would have done: Element* element = selection->rootEditableElement(); if (!element) return false; instead of checking isContentEditable then implicitly assuming that element is not null. > Source/WebKit/chromium/src/WebViewImpl.cpp:1532 > + if (!range.get()) > + return false; > + > + if (!TextIterator::locationAndLengthFromRange(range.get(), location, length)) > + return false; You can combine these two statements: if (!range || TextIterator::locationAndLengthFromRange(range.get(), location, length)) (notice there's no need to call get() on the nullity check). > Source/WebKit/chromium/src/WebViewImpl.h:123 > + virtual bool surroundingTextWithSelection( > + WebString& text, > + size_t& focus, > + size_t& anchor) const; Ditto about putting it in one line and omitting text. 460905 38 106061 penghuang 2011-09-01 16:32:44 -0700 Created attachment 106061 Patch 460913 39 106061 rniwa 2011-09-01 16:41:18 -0700 Comment on attachment 106061 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=106061&action=review > Source/WebKit/chromium/ChangeLog:8 > + Add surroundingTextWithSelection() to Chromium's WebViewImpl This doesn't explain anything about the function. In fact, I can see that from the code change. What I'd like to know instead is why we're adding this function and why it has this particular interface, etc... > Source/WebKit/chromium/public/WebWidget.h:154 > + virtual bool surroundingTextWithSelection(WebString&, size_t& focus, size_t& anchor) const { return false; } I don't think "surroundingText" is a good name here because what it surrounds is ambiguous. Maybe getSelectionOffsetsAndTextInEditableElement? > Source/WebKit/chromium/src/WebViewImpl.cpp:1512 > +bool WebViewImpl::surroundingTextWithSelection( > + WebString& text, size_t& focus, size_t& anchor) const Nit: I would put all in one line. > Source/WebKit/chromium/src/WebViewImpl.cpp:1523 > + text = element->innerText(); It seems odd that we'll obtain text even when selection range is 0 or locationAndLengthFromRange returns false. Since innerText is a pretty expensive operation, we should probably move this below that return statement. 460916 40 rniwa 2011-09-01 16:43:46 -0700 s/getSelectionOffsetsAndTextInEditableElement/getSelectionOffsetsAndTextInRootEditableElement/. 460959 41 penghuang 2011-09-01 17:43:03 -0700 (In reply to comment #39) > > I don't think "surroundingText" is a good name here because what it surrounds is ambiguous. Maybe getSelectionOffsetsAndTextInEditableElement? I think surroundingText is accurate even without WithSelection suffix (Without the cursor position, this text is useless. Or we need return two pieces of text. before cursor and after cursor). Maybe it is little brief, but it could be clear with a good document. At same time, the input methods just need a small piece of text surrounding the input cursor (The Surrounding Text concept is from qt and gtk), they do not need all content in the editable element. one paragraph is enough. Although this function returns all content in the root editable element currently, but we may optimize it to return a text in reasonable size in future. Especially in Chrome OS, those data will be transferred between several processes (webkit, chrome ui, input daemon and input engine process) frequently. Too large is not efficient. > > > Source/WebKit/chromium/src/WebViewImpl.cpp:1512 > > +bool WebViewImpl::surroundingTextWithSelection( > > + WebString& text, size_t& focus, size_t& anchor) const > > Nit: I would put all in one line. I could put all in one line, but it will be very long. 460962 42 rniwa 2011-09-01 17:50:43 -0700 (In reply to comment #41) > I think surroundingText is accurate even without WithSelection suffix (Without the cursor position, this text is useless. Or we need return two pieces of text. before cursor and after cursor). Maybe it is little brief, but it could be clear with a good document. In WebKit, we avoid documentation in the favor of self-evident code. We should avoid giving a function name that requires comment or documentation to convey its purpose. > At same time, the input methods just need a small piece of text surrounding the input cursor (The Surrounding Text concept is from qt and gtk), they do not need all content in the editable element. one paragraph is enough. Although this function returns all content in the root editable element currently, but we may optimize it to return a text in reasonable size in future. Fair enough. But we should still emphasize the fact this function only works within an editable content. > > > Source/WebKit/chromium/src/WebViewImpl.cpp:1512 > > > +bool WebViewImpl::surroundingTextWithSelection( > > > + WebString& text, size_t& focus, size_t& anchor) const > > > > Nit: I would put all in one line. > I could put all in one line, but it will be very long. I don't think 101 characters is considered long in WebKit's code base. 460989 43 hbono 2011-09-01 18:30:15 -0700 Greetings, This is just an off-the-topic question: it seems this change does not check whether the focused element is a password field. I'm wondering how this change prevents IMEs from reading text in password fields as [WebHTMLView attributedSubStringFromRange] does. If I recall correctly, Chrome OS has an IME extension API so extension developers can implement IMEs and virtual keyboards. If WebKit allows IMEs to read text in password fields, it may allow extension developers to read text in password fields. (I'm not sure if it is good to allow such extension developers to read text in other input fields.) By the way, to implement [attributedSubstringFromRange:nsRange], Mac Chrome adds the WebKit::WebSubstringUtil class. Maybe we use this class for consistency? (Even though this is a random thought, it seems Mac Chrome uses a round-trip IPC request to implement this method. It might be better for a renderer to send attributed substring to a browser when it is changed to avoid such round-trip IPCs as we send cursor position?) Regards, Hironori Bono 461230 44 penghuang 2011-09-02 08:09:17 -0700 (In reply to comment #43) > Greetings, > > This is just an off-the-topic question: it seems this change does not check whether the focused element is a password field. I'm wondering how this change prevents IMEs from reading text in password fields as [WebHTMLView attributedSubStringFromRange] does. If I recall correctly, Chrome OS has an IME extension API so extension developers can implement IMEs and virtual keyboards. If WebKit allows IMEs to read text in password fields, it may allow extension developers to read text in password fields. (I'm not sure if it is good to allow such extension developers to read text in other input fields.) > > By the way, to implement [attributedSubstringFromRange:nsRange], Mac Chrome adds the WebKit::WebSubstringUtil class. Maybe we use this class for consistency? (Even though this is a random thought, it seems Mac Chrome uses a round-trip IPC request to implement this method. It might be better for a renderer to send attributed substring to a browser when it is changed to avoid such round-trip IPCs as we send cursor position?) http://codereview.chromium.org/7824037/diff/1/content/renderer/render_widget.cc Here is the related code in chromium. I plan check password field in chromium side. I think it is a little more efficient. Anyway, we could add check code in webkit as well. At same time, it will notify input method any changes of surrounding text instead of sync round-trip IPCs. 461427 45 106175 penghuang 2011-09-02 12:30:38 -0700 Created attachment 106175 Patch 461432 46 106175 rniwa 2011-09-02 12:34:43 -0700 Comment on attachment 106175 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=106175&action=review > Source/WebKit/chromium/public/WebWidget.h:153 > + virtual bool getTextSurroundEditCaret(WebString&, size_t& focus, size_t& anchor) const { return false; } "EditCaret" is inaccurate name because non-collapsed selection isn't a caret. Also you have two verbs (get & surround) here. It sounds as if you're making the text surround "edit-caret". 461470 47 penghuang 2011-09-02 13:23:26 -0700 (In reply to comment #46) > (From update of attachment 106175 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=106175&action=review > > > Source/WebKit/chromium/public/WebWidget.h:153 > > + virtual bool getTextSurroundEditCaret(WebString&, size_t& focus, size_t& anchor) const { return false; } > > "EditCaret" is inaccurate name because non-collapsed selection isn't a caret. Also you have two verbs (get & surround) here. It sounds as if you're making the text surround "edit-caret". Several candidates, please choice one. textAroundEditCaret(), getTextAroundEditCaret(), surroundingTextInEditableElement(), getSurroundingTextInEditableElement(). 461476 48 rniwa 2011-09-02 13:31:19 -0700 (In reply to comment #47) > Several candidates, please choice one. > > textAroundEditCaret(), getTextAroundEditCaret(), surroundingTextInEditableElement(), getSurroundingTextInEditableElement(). You probably need to include the word selection there because this API also obtains anchor and focus offsets. Given that, how about getSelectionOffsetsAndTextInEditableContent? 461480 49 penghuang 2011-09-02 13:38:40 -0700 (In reply to comment #48) > (In reply to comment #47) > > Several candidates, please choice one. > > > > textAroundEditCaret(), getTextAroundEditCaret(), surroundingTextInEditableElement(), getSurroundingTextInEditableElement(). > > You probably need to include the word selection there because this API also obtains anchor and focus offsets. Given that, how about getSelectionOffsetsAndTextInEditableContent? OK. 461496 50 106189 penghuang 2011-09-02 13:53:14 -0700 Created attachment 106189 Patch 461497 51 106189 rniwa 2011-09-02 13:57:46 -0700 Comment on attachment 106189 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=106189&action=review > Source/WebKit/chromium/src/WebViewImpl.cpp:1518 > + Element* element = selection->rootEditableElement(); I think selection could be null here. 461504 52 penghuang 2011-09-02 14:03:51 -0700 (In reply to comment #51) > (From update of attachment 106189 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=106189&action=review > > > Source/WebKit/chromium/src/WebViewImpl.cpp:1518 > > + Element* element = selection->rootEditableElement(); > > I think selection could be null here. Checked the code. It returns &m_selection; So it should not be null. 461605 53 106189 webkit.review.bot 2011-09-02 16:06:34 -0700 Comment on attachment 106189 Patch Clearing flags on attachment: 106189 Committed r94459: <http://trac.webkit.org/changeset/94459> 461606 54 webkit.review.bot 2011-09-02 16:06:42 -0700 All reviewed patches have been landed. Closing bug. 630731 55 abarth 2012-05-22 14:04:28 -0700 Re-opened since this is blocked by 87164 630756 56 rniwa 2012-05-22 14:21:35 -0700 (In reply to comment #55) > Re-opened since this is blocked by 87164 Why is this bug blocked by https://bugs.webkit.org/show_bug.cgi?id=87164 ? That one looks totally unrelated. 630789 57 abarth 2012-05-22 14:49:10 -0700 Sorry. I typoed 66687 104692 2011-08-22 10:22:18 -0700 2011-08-30 13:35:51 -0700 Patch bug-66681-20110822132202.patch text/plain 4234 penghuang U3VidmVyc2lvbiBSZXZpc2lvbjogOTM1MDgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXgg ODQ4MGY1NGIwNTZiZjk2ZWNmYjkyMzA1NWFjZjExMGJjMjRmMzRlNi4uNWM4NGY5ZGFkNTQwZGMy N2EwNDVhNjY3MDZkYTQ5OWYzNDdlZGM5NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxNiBAQAorMjAxMS0wOC0yMiAgUGVuZyBIdWFuZyAgPHBlbmdodWFuZ0BjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgQWRkIEFQSSBmb3IgZ2V0dGluZyBzdXJyb3VuZGluZyB0ZXh0IGZy b20gd2Via2l0IGluIGNocm9taXVtCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD02NjY4MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgICogcHVibGljL1dlYldpZGdldC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJX aWRnZXQ6OnN1cnJvdW5kaW5nKToKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuY3BwOgorICAg ICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6c3Vycm91bmRpbmcpOgorICAgICAgICAqIHNyYy9X ZWJWaWV3SW1wbC5oOgorCiAyMDExLTA4LTIwICBOZWJvanNhIENpcmljICA8Y2lyYUBjaHJvbWl1 bS5vcmc+CiAKICAgICAgICAgQWRkIGRlcGVuZGVuY3kgb24gdjgtaTE4biBsaWJyYXJ5LiBXZSB1 c2VkIHY4IHJlcG9zaXRvcnkgYmVmb3JlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViV2lkZ2V0LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9X ZWJXaWRnZXQuaAppbmRleCBmNmU3M2YxYjQ2NDIxZDZhNGNjMDMzZmVlODcyZTZkODNjNGQyOTEx Li4xNzdhYTA1YTBlMWIzYzkyZDAxYzIxNjFiOTgyZTE5ZTIyYmM5NGM5IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJXaWRnZXQuaAorKysgYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJXaWRnZXQuaApAQCAtMTQ3LDYgKzE0NywxMiBAQCBwdWJs aWM6CiAgICAgLy8gUmV0dXJucyB0aGUgY3VycmVudCB0ZXh0IGlucHV0IHR5cGUgb2YgdGhpcyBX ZWJXaWRnZXQuCiAgICAgdmlydHVhbCBXZWJUZXh0SW5wdXRUeXBlIHRleHRJbnB1dFR5cGUoKSB7 IHJldHVybiBXZWJLaXQ6OldlYlRleHRJbnB1dFR5cGVOb25lOyB9CiAKKyAgICAvLyBSZXR1cm5z IHRoZSBwbGFpbiB0ZXh0IGFyb3VuZCB0aGUgaW5wdXQgYXJlYSwgZm9yIGV4YW1wbGUgdGhlIGN1 cnJlbnQKKyAgICAvLyBwYXJhZ3JhcGguIFRoZSBjdXJzb3IgaXMgdGhlIGluZGV4IG9mIHRoZSBp bnB1dCBjdXJzb3IgaW4gdGhlIHRleHQuCisgICAgLy8gVGhlIGFuY2hvciBpcyB0aGUgaW5kZXgg b2YgdGhlIHNlbGVjdGlvbiBhbmNob3IgaW4gdGhlIHRleHQuIElmIHRoZXJlIGlzCisgICAgLy8g bm8gc2VsZWN0aW9uLCBhbmNob3IgaXMgc2FtZSBhcyB0aGUgY3Vyc29yLgorICAgIHZpcnR1YWwg Ym9vbCBzdXJyb3VuZGluZyhXZWJTdHJpbmcmIHRleHQsIHNpemVfdCYgY3Vyc29yLCBzaXplX3Qm IGFuY2hvcikgeyByZXR1cm4gZmFsc2U7IH0KKwogICAgIC8vIFJldHVybnMgdGhlIGN1cnJlbnQg Y2FyZXQgYm91bmRzIG9mIHRoaXMgV2ViV2lkZ2V0LiBUaGUgc2VsZWN0aW9uIGJvdW5kcwogICAg IC8vIHdpbGwgYmUgcmV0dXJuZWQgaWYgYSBzZWxlY3Rpb24gcmFuZ2UgaXMgYXZhaWxhYmxlLgog ICAgIHZpcnR1YWwgV2ViUmVjdCBjYXJldE9yU2VsZWN0aW9uQm91bmRzKCkgeyByZXR1cm4gV2Vi UmVjdCgpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3 SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKaW5k ZXggN2IyYjRlNDE5Y2UwMDU2Y2FjZWY2YjM3ZWQ0ZDYyZjU3Y2QzNTZmMC4uNTc4NmUwNmFhMmQ5 YWQ2ZjdlMWIwMGRiNzM1NmM2YjhiNWU5MjQ1ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYlZpZXdJbXBsLmNwcApAQCAtMTUwOSw2ICsxNTA5LDQwIEBAIFdlYlRleHRJbnB1dFR5 cGUgV2ViVmlld0ltcGw6OnRleHRJbnB1dFR5cGUoKQogICAgIHJldHVybiBXZWJUZXh0SW5wdXRU eXBlTm9uZTsKIH0KIAorYm9vbCBXZWJWaWV3SW1wbDo6c3Vycm91bmRpbmcoV2ViU3RyaW5nJiB0 ZXh0LCBzaXplX3QmIGN1cnNvciwgc2l6ZV90JiBhbmNob3IpCit7CisgICAgdGV4dC5yZXNldCgp OworICAgIGN1cnNvciA9IDA7CisgICAgYW5jaG9yID0gMDsKKworICAgIGNvbnN0IEZyYW1lKiBm cmFtZSA9IGZvY3VzZWRXZWJDb3JlRnJhbWUoKTsKKyAgICBpZiAoIWZyYW1lKQorICAgICAgICBy ZXR1cm4gZmFsc2U7CisKKyAgICBGcmFtZVNlbGVjdGlvbiogc2VsZWN0aW9uID0gZnJhbWUtPnNl bGVjdGlvbigpOworICAgIGlmICghc2VsZWN0aW9uLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQorICAg ICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBFbGVtZW50KiBlbGVtZW50ID0gc2VsZWN0aW9uLT5y b290RWRpdGFibGVFbGVtZW50KCk7CisgICAgdGV4dCA9IGVsZW1lbnQtPmlubmVyVGV4dCgpOwor CisgICAgRWxlbWVudCogc2VsZWN0aW9uUm9vdCA9IHNlbGVjdGlvbi0+cm9vdEVkaXRhYmxlRWxl bWVudCgpOworICAgIEVsZW1lbnQqIHNjb3BlID0gc2VsZWN0aW9uUm9vdCA/IHNlbGVjdGlvblJv b3QgOiBmcmFtZS0+ZG9jdW1lbnQoKS0+ZG9jdW1lbnRFbGVtZW50KCk7CisKKyAgICBSZWZQdHI8 UmFuZ2U+IHRlc3RSYW5nZSA9IFJhbmdlOjpjcmVhdGUoCisgICAgICAgIHNjb3BlLT5kb2N1bWVu dCgpLCBzY29wZSwgMCwKKyAgICAgICAgc2VsZWN0aW9uLT5iYXNlKCkuY29udGFpbmVyTm9kZSgp LCBzZWxlY3Rpb24tPmJhc2UoKS5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKSk7CisgICAgYW5jaG9y ID0gVGV4dEl0ZXJhdG9yOjpyYW5nZUxlbmd0aCh0ZXN0UmFuZ2UuZ2V0KCkpOworCisgICAgRXhj ZXB0aW9uQ29kZSBlYzsKKyAgICB0ZXN0UmFuZ2UtPnNldEVuZChzZWxlY3Rpb24tPmV4dGVudCgp LmNvbnRhaW5lck5vZGUoKSwgc2VsZWN0aW9uLT5leHRlbnQoKS5vZmZzZXRJbkNvbnRhaW5lck5v ZGUoKSwgZWMpOworICAgIGN1cnNvciA9IFRleHRJdGVyYXRvcjo6cmFuZ2VMZW5ndGgodGVzdFJh bmdlLmdldCgpKTsKKworICAgIC8vIFRPRE8gdHJ1bmNhdGUgdGhlIHRleHQgaW50byByZWFuc29u YWJsZSBzaXplCisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogV2ViUmVjdCBXZWJWaWV3SW1wbDo6 Y2FyZXRPclNlbGVjdGlvbkJvdW5kcygpCiB7CiAgICAgV2ViUmVjdCByZWN0OwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaCBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKaW5kZXggYzdjZDEyYjY3MDRkYzk1NjIwNGIx MDQ3NTM2Y2JkYTFiYjE2NjQ5Yy4uMDIzYzY5MDYxNjgyMGE2NzY0ZmQxZjU5MWE0OGVlOTNjZTVl MWU0MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwu aAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBAIC0xMTcs NiArMTE3LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBjb25maXJtQ29tcG9zaXRpb24o Y29uc3QgV2ViU3RyaW5nJiB0ZXh0KTsKICAgICB2aXJ0dWFsIGJvb2wgY29tcG9zaXRpb25SYW5n ZShzaXplX3QqIGxvY2F0aW9uLCBzaXplX3QqIGxlbmd0aCk7CiAgICAgdmlydHVhbCBXZWJUZXh0 SW5wdXRUeXBlIHRleHRJbnB1dFR5cGUoKTsKKyAgICB2aXJ0dWFsIGJvb2wgc3Vycm91bmRpbmco V2ViU3RyaW5nJiB0ZXh0LCBzaXplX3QmIGN1cnNvciwgc2l6ZV90JiBhbmNob3IpOwogICAgIHZp cnR1YWwgV2ViUmVjdCBjYXJldE9yU2VsZWN0aW9uQm91bmRzKCk7CiAgICAgdmlydHVhbCBib29s IHNlbGVjdGlvblJhbmdlKFdlYlBvaW50JiBzdGFydCwgV2ViUG9pbnQmIGVuZCkgY29uc3Q7CiAg ICAgdmlydHVhbCBib29sIGNhcmV0T3JTZWxlY3Rpb25SYW5nZShzaXplX3QqIGxvY2F0aW9uLCBz aXplX3QqIGxlbmd0aCk7Cg== 105686 2011-08-30 13:35:58 -0700 2011-09-01 14:49:33 -0700 Patch bug-66681-20110830163545.patch text/plain 6678 penghuang U3VidmVyc2lvbiBSZXZpc2lvbjogOTQwODYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA1ZjAzYjA5ZTVjMzlkNWM0 N2Y3ODRhYTg4NDVkZjlhNDA2ODM2MjM5Li40Y2FlMzhkODAxZWIwYTNjMzQ5MWJjMWU3NTJjMGUz NzM2YjI5NTlkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDgtMzAgIFBlbmcg SHVhbmcgIDxwZW5naHVhbmdAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBmdW5jdGlvbiBm b3IgZ2V0dGluZyBzdXJyb3VuZGluZyB0ZXh0IGZyb20gRnJhbWVTZWxlY3Rpb24KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY2NjgxCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiAoT09Q UyEpCisKKyAgICAgICAgKiBlZGl0aW5nL0ZyYW1lU2VsZWN0aW9uLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkZyYW1lU2VsZWN0aW9uOjpnZXRTdXJyb3VuZGluZ1RleHQpOgorICAgICAgICAqIGVk aXRpbmcvRnJhbWVTZWxlY3Rpb24uaDoKKwogMjAxMS0wOC0zMCAgVG9ueSBDaGFuZyAgPHRvbnlA Y2hyb21pdW0ub3JnPgogCiAgICAgICAgIEZpeCBjb21waWxlIHdhcm5pbmcgb24gY2xhbmc6CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0ZyYW1lU2VsZWN0aW9uLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL2VkaXRpbmcvRnJhbWVTZWxlY3Rpb24uY3BwCmluZGV4IDE4ZmU5ZWY0YmEx YmM1MGJjNDg4MzVlNTI5MzI1Y2ZjMTlmYmMwZTQuLjNjMzVkMTg3OTM3OTA5ZmYyNDk3YzY3MGNl YWI5OTU4ZDIwMTQzNTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRnJhbWVT ZWxlY3Rpb24uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRnJhbWVTZWxlY3Rpb24u Y3BwCkBAIC0xODg0LDYgKzE4ODQsMzEgQEAgYm9vbCBGcmFtZVNlbGVjdGlvbjo6c2hvdWxkQ2hh bmdlU2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIG5ld1NlbGVjdGlvbikKICAgICBy ZXR1cm4gbV9mcmFtZS0+ZWRpdG9yKCktPnNob3VsZENoYW5nZVNlbGVjdGlvbihzZWxlY3Rpb24o KSwgbmV3U2VsZWN0aW9uLCBuZXdTZWxlY3Rpb24uYWZmaW5pdHkoKSwgZmFsc2UpOwogfQogCiti b29sIEZyYW1lU2VsZWN0aW9uOjpnZXRTdXJyb3VuZGluZ1RleHQoU3RyaW5nJiB0ZXh0LCBzaXpl X3QmIGZvY3VzLCBzaXplX3QmIGFuY2hvcikgY29uc3QKK3sKKyAgICBpZiAoIWlzQ29udGVudEVk aXRhYmxlKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIEVsZW1lbnQqIGVsZW1lbnQg PSByb290RWRpdGFibGVFbGVtZW50KCk7CisgICAgaWYgKCFlbGVtZW50KQorICAgICAgICByZXR1 cm4gZmFsc2U7CisKKyAgICB0ZXh0ID0gZWxlbWVudC0+aW5uZXJUZXh0KCk7CisKKyAgICBSZWZQ dHI8UmFuZ2U+IHRlc3RSYW5nZSA9IFJhbmdlOjpjcmVhdGUoCisgICAgICAgIGVsZW1lbnQtPmRv Y3VtZW50KCksIGVsZW1lbnQsIDAsCisgICAgICAgIGJhc2UoKS5jb250YWluZXJOb2RlKCksIGJh c2UoKS5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKSk7CisgICAgYW5jaG9yID0gVGV4dEl0ZXJhdG9y OjpyYW5nZUxlbmd0aCh0ZXN0UmFuZ2UuZ2V0KCkpOworCisgICAgRXhjZXB0aW9uQ29kZSBlYzsK KyAgICB0ZXN0UmFuZ2UtPnNldEVuZChleHRlbnQoKS5jb250YWluZXJOb2RlKCksCisgICAgICAg IGV4dGVudCgpLm9mZnNldEluQ29udGFpbmVyTm9kZSgpLCBlYyk7CisgICAgZm9jdXMgPSBUZXh0 SXRlcmF0b3I6OnJhbmdlTGVuZ3RoKHRlc3RSYW5nZS5nZXQoKSk7CisKKyAgICAvLyBGSVhNRSB0 cnVuY2F0ZSB0aGUgdGV4dCBpbnRvIHJlYW5zb25hYmxlIHNpemUKKyAgICByZXR1cm4gdHJ1ZTsK K30KKwogI2lmbmRlZiBOREVCVUcKIAogdm9pZCBGcmFtZVNlbGVjdGlvbjo6Zm9ybWF0Rm9yRGVi dWdnZXIoY2hhciogYnVmZmVyLCB1bnNpZ25lZCBsZW5ndGgpIGNvbnN0CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9lZGl0aW5nL0ZyYW1lU2VsZWN0aW9uLmggYi9Tb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL0ZyYW1lU2VsZWN0aW9uLmgKaW5kZXggOTYxOWRmNTc0NDhiZWRlNzQwMGQ1OWJkZjAz YTAxZmI5ZTM0YmVjMy4uMWMyNmQ1OGE5Nzg2Njc0ZWYyMWNiM2IyMzQzMTk3YzI0M2M4ZDU2MSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9GcmFtZVNlbGVjdGlvbi5oCisrKyBi L1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRnJhbWVTZWxlY3Rpb24uaApAQCAtMjQzLDYgKzI0Myw4 IEBAIHB1YmxpYzoKICAgICB2b2lkIHJldmVhbFNlbGVjdGlvbihjb25zdCBTY3JvbGxBbGlnbm1l bnQmID0gU2Nyb2xsQWxpZ25tZW50OjphbGlnbkNlbnRlcklmTmVlZGVkLCBib29sIHJldmVhbEV4 dGVudCA9IGZhbHNlKTsKICAgICB2b2lkIHNldFNlbGVjdGlvbkZyb21Ob25lKCk7CiAKKyAgICBi b29sIGdldFN1cnJvdW5kaW5nVGV4dChTdHJpbmcmLCBzaXplX3QmLCBzaXplX3QmKSBjb25zdDsK KwogcHJpdmF0ZToKICAgICBlbnVtIEVQb3NpdGlvblR5cGUgeyBTVEFSVCwgRU5ELCBCQVNFLCBF WFRFTlQgfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCBlMThkZTlhYWY1MjE2ZDhj OGU1MWE4YjM2NzA3MzQ5M2JlNmU3OTc2Li5mOTBiNzc3MWViZGZhMmUyOWZiNDFkYmZjNmEyMTlh N2RjMGM0ZjRiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwor KysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisy MDExLTA4LTMwICBQZW5nIEh1YW5nICA8cGVuZ2h1YW5nQGNocm9taXVtLm9yZz4KKworICAgICAg ICBBZGQgQVBJIGZvciBnZXR0aW5nIHN1cnJvdW5kaW5nIHRleHQgZnJvbSB3ZWJraXQgaW4gY2hy b21pdW0KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY2 NjgxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBw dWJsaWMvV2ViV2lkZ2V0Lmg6CisgICAgICAgIChXZWJLaXQ6OldlYldpZGdldDo6Z2V0U3Vycm91 bmRpbmdUZXh0KToKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuY3BwOgorICAgICAgICAoV2Vi S2l0OjpXZWJWaWV3SW1wbDo6c2V0RGV2VG9vbHNBZ2VudENsaWVudCk6CisgICAgICAgIChXZWJL aXQ6OldlYlZpZXdJbXBsOjpnZXRTdXJyb3VuZGluZ1RleHQpOgorICAgICAgICAqIHNyYy9XZWJW aWV3SW1wbC5oOgorCiAyMDExLTA4LTMwICBUb255IENoYW5nICA8dG9ueUBjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUm9sbCBjaHJvbWl1bSBERVBTIHRvIHI5ODc3MS4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYldpZGdldC5oIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViV2lkZ2V0LmgKaW5kZXggMWJjMTkxY2MzNWJmNzY5MDA5MGIwODBm OGJhOTY3YWM0YWUzODkzMy4uOWE5ZTA2OWE3Y2Q2MDMxMmVmY2I2NDVmODBkZjJlYzdkZGMyZTgz MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViV2lkZ2V0LmgK KysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViV2lkZ2V0LmgKQEAgLTE0Nyw2 ICsxNDcsMTUgQEAgcHVibGljOgogICAgIC8vIFJldHVybnMgdGhlIGN1cnJlbnQgdGV4dCBpbnB1 dCB0eXBlIG9mIHRoaXMgV2ViV2lkZ2V0LgogICAgIHZpcnR1YWwgV2ViVGV4dElucHV0VHlwZSB0 ZXh0SW5wdXRUeXBlKCkgeyByZXR1cm4gV2ViS2l0OjpXZWJUZXh0SW5wdXRUeXBlTm9uZTsgfQog CisgICAgLy8gUmV0dXJucyB0aGUgcGxhaW4gdGV4dCBhcm91bmQgdGhlIGlucHV0IGFyZWEsIGZv ciBleGFtcGxlIHRoZSBjdXJyZW50CisgICAgLy8gcGFyYWdyYXBoLiBUaGUgZm9jdXMgaXMgdGhl IGluZGV4IG9mIHRoZSBpbnB1dCBjdXJzb3IgaW4gdGhlIHRleHQuCisgICAgLy8gVGhlIGFuY2hv ciBpcyB0aGUgaW5kZXggb2YgdGhlIHNlbGVjdGlvbiBhbmNob3IgaW4gdGhlIHRleHQuIElmIHRo ZXJlIGlzCisgICAgLy8gbm8gc2VsZWN0aW9uLCBhbmNob3IgaXMgc2FtZSBhcyB0aGUgY3Vyc29y LgorICAgIHZpcnR1YWwgYm9vbCBnZXRTdXJyb3VuZGluZ1RleHQoCisgICAgICAgIFdlYlN0cmlu ZyYgdGV4dCwKKyAgICAgICAgc2l6ZV90JiBmb2N1cywKKyAgICAgICAgc2l6ZV90JiBhbmNob3Ip IGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CisKICAgICAvLyBSZXR1cm5zIHRoZSBjdXJyZW50IGNh cmV0IGJvdW5kcyBvZiB0aGlzIFdlYldpZGdldC4gVGhlIHNlbGVjdGlvbiBib3VuZHMKICAgICAv LyB3aWxsIGJlIHJldHVybmVkIGlmIGEgc2VsZWN0aW9uIHJhbmdlIGlzIGF2YWlsYWJsZS4KICAg ICB2aXJ0dWFsIFdlYlJlY3QgY2FyZXRPclNlbGVjdGlvbkJvdW5kcygpIHsgcmV0dXJuIFdlYlJl Y3QoKTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0lt cGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4 IDIwMzYyOTAyNjdmYjE2NWNjMDY5NTc0MjhkYjIxNTMwNTVkZTExYzAuLmJjNGFmZTliZDBkNDc2 MGI1ODEyNDM4NDAyNzRkM2UwMDlhOTM4MmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJWaWV3SW1wbC5jcHAKQEAgLTI5Miw3ICsyOTIsNyBAQCB2b2lkIFdlYlZpZXdJbXBsOjpz ZXRBdXRvZmlsbENsaWVudChXZWJBdXRvZmlsbENsaWVudCogYXV0b2ZpbGxDbGllbnQpCiAgICAg bV9hdXRvZmlsbENsaWVudCA9IGF1dG9maWxsQ2xpZW50OwogfQogCi12b2lkIFdlYlZpZXdJbXBs OjpzZXREZXZUb29sc0FnZW50Q2xpZW50KFdlYkRldlRvb2xzQWdlbnRDbGllbnQqIGRldlRvb2xz Q2xpZW50KSAKK3ZvaWQgV2ViVmlld0ltcGw6OnNldERldlRvb2xzQWdlbnRDbGllbnQoV2ViRGV2 VG9vbHNBZ2VudENsaWVudCogZGV2VG9vbHNDbGllbnQpCiB7CiAgICAgaWYgKGRldlRvb2xzQ2xp ZW50KQogICAgICAgICBtX2RldlRvb2xzQWdlbnQgPSBhZG9wdFB0cihuZXcgV2ViRGV2VG9vbHNB Z2VudEltcGwodGhpcywgZGV2VG9vbHNDbGllbnQpKTsKQEAgLTE1MDEsNiArMTUwMSwyMiBAQCBX ZWJUZXh0SW5wdXRUeXBlIFdlYlZpZXdJbXBsOjp0ZXh0SW5wdXRUeXBlKCkKICAgICByZXR1cm4g V2ViVGV4dElucHV0VHlwZU5vbmU7CiB9CiAKK2Jvb2wgV2ViVmlld0ltcGw6OmdldFN1cnJvdW5k aW5nVGV4dCgKKyAgICBXZWJTdHJpbmcmIHRleHQsIHNpemVfdCYgZm9jdXMsIHNpemVfdCYgYW5j aG9yKSBjb25zdAoreworICAgIGNvbnN0IEZyYW1lKiBmcmFtZSA9IGZvY3VzZWRXZWJDb3JlRnJh bWUoKTsKKyAgICBpZiAoIWZyYW1lKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBGcmFt ZVNlbGVjdGlvbiogc2VsZWN0aW9uID0gZnJhbWUtPnNlbGVjdGlvbigpOworCisgICAgU3RyaW5n IHRtcDsKKyAgICBpZiAoIXNlbGVjdGlvbi0+Z2V0U3Vycm91bmRpbmdUZXh0KHRtcCwgZm9jdXMs IGFuY2hvcikpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB0ZXh0ID0gdG1wOworICAgIHJl dHVybiB0cnVlOworfQorCiBXZWJSZWN0IFdlYlZpZXdJbXBsOjpjYXJldE9yU2VsZWN0aW9uQm91 bmRzKCkKIHsKICAgICBXZWJSZWN0IHJlY3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi Vmlld0ltcGwuaAppbmRleCAwMWZjOTEwNWMwZGY3NmE0NmM1ZTFjMGQyYjU3MzMzZWRmYTMzMzdk Li5hYjExOTQ2ZTBjMTUzNmI3YWVhYjYwNjg3NzE1OTNmMWIyOGFhNjJmIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKQEAgLTExNyw2ICsxMTcsNyBAQCBwdWJsaWM6 CiAgICAgdmlydHVhbCBib29sIGNvbmZpcm1Db21wb3NpdGlvbihjb25zdCBXZWJTdHJpbmcmIHRl eHQpOwogICAgIHZpcnR1YWwgYm9vbCBjb21wb3NpdGlvblJhbmdlKHNpemVfdCogbG9jYXRpb24s IHNpemVfdCogbGVuZ3RoKTsKICAgICB2aXJ0dWFsIFdlYlRleHRJbnB1dFR5cGUgdGV4dElucHV0 VHlwZSgpOworICAgIHZpcnR1YWwgYm9vbCBnZXRTdXJyb3VuZGluZ1RleHQoV2ViU3RyaW5nJiB0 ZXh0LCBzaXplX3QmIGZvY3VzLCBzaXplX3QmIGFuY2hvcikgY29uc3Q7CiAgICAgdmlydHVhbCBX ZWJSZWN0IGNhcmV0T3JTZWxlY3Rpb25Cb3VuZHMoKTsKICAgICB2aXJ0dWFsIGJvb2wgc2VsZWN0 aW9uUmFuZ2UoV2ViUG9pbnQmIHN0YXJ0LCBXZWJQb2ludCYgZW5kKSBjb25zdDsKICAgICB2aXJ0 dWFsIGJvb2wgY2FyZXRPclNlbGVjdGlvblJhbmdlKHNpemVfdCogbG9jYXRpb24sIHNpemVfdCog bGVuZ3RoKTsK 106034 2011-09-01 14:49:42 -0700 2011-09-01 15:21:59 -0700 Patch bug-66681-20110901174936.patch text/plain 5058 penghuang U3VidmVyc2lvbiBSZXZpc2lvbjogOTQzNDAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXgg NDJjYTcyNzFmOTEwN2I2YWQ3YjMzODc3MDVjNTY5NTkxNjlkMTVmNy4uZTcyYTA4ZjFiYjg4MDgy OWVlNGRmMjk5OGM2MThiNTlhM2QxNjBhMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxNyBAQAorMjAxMS0wOS0wMSAgUGVuZyBIdWFuZyAgPHBlbmdodWFuZ0BjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgQWRkIEFQSSBmb3IgZ2V0dGluZyBzdXJyb3VuZGluZyB0ZXh0IGFu ZCBzZWxlY3Rpb24gcmFuZ2UKKyAgICAgICAgZnJvbSB3ZWJraXQgaW4gY2hyb21pdW0uCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NjY4MQorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcHVibGljL1dlYldp ZGdldC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJXaWRnZXQ6OnN1cnJvdW5kaW5nVGV4dFdpdGhT ZWxlY3Rpb24pOgorICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5jcHA6CisgICAgICAgIChXZWJL aXQ6OldlYlZpZXdJbXBsOjpzdXJyb3VuZGluZ1RleHRXaXRoU2VsZWN0aW9uKToKKyAgICAgICAg KiBzcmMvV2ViVmlld0ltcGwuaDoKKwogMjAxMS0wOC0zMSAgR3JlZyBCaWxsb2NrICA8Z2JpbGxv Y2tAZ29vZ2xlLmNvbT4KIAogICAgICAgICBBZGQgcGFzcy10aHJvdWdocyBmb3IgTlBPYmplY3Qv djg6OlZhbHVlIG1hcnNoYWxsaW5nIHRvIFdlYkJpbmRpbmdzCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJXaWRnZXQuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYldpZGdldC5oCmluZGV4IDFiYzE5MWNjMzViZjc2OTAwOTBiMDgwZjhiYTk2 N2FjNGFlMzg5MzMuLmRjMWQzYjUzNmYyZDhlM2ExNGFhMzNmMjMwNDYxNTY0OTc0N2U0NDAgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYldpZGdldC5oCisrKyBi L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYldpZGdldC5oCkBAIC0xNDcsNiArMTQ3 LDE1IEBAIHB1YmxpYzoKICAgICAvLyBSZXR1cm5zIHRoZSBjdXJyZW50IHRleHQgaW5wdXQgdHlw ZSBvZiB0aGlzIFdlYldpZGdldC4KICAgICB2aXJ0dWFsIFdlYlRleHRJbnB1dFR5cGUgdGV4dElu cHV0VHlwZSgpIHsgcmV0dXJuIFdlYktpdDo6V2ViVGV4dElucHV0VHlwZU5vbmU7IH0KIAorICAg IC8vIFJldHVybnMgdGhlIHBsYWluIHRleHQgYXJvdW5kIHRoZSBpbnB1dCBhcmVhLCBmb3IgZXhh bXBsZSB0aGUgY3VycmVudAorICAgIC8vIHBhcmFncmFwaC4gVGhlIGZvY3VzIGlzIHRoZSBpbmRl eCBvZiB0aGUgaW5wdXQgY3Vyc29yIGluIHRoZSB0ZXh0LgorICAgIC8vIFRoZSBhbmNob3IgaXMg dGhlIGluZGV4IG9mIHRoZSBzZWxlY3Rpb24gYW5jaG9yIGluIHRoZSB0ZXh0LiBJZiB0aGVyZSBp cworICAgIC8vIG5vIHNlbGVjdGlvbiwgZm9jdXMgYW5kIGFuY2hvciBhcmUgc2FtZS4KKyAgICB2 aXJ0dWFsIGJvb2wgc3Vycm91bmRpbmdUZXh0V2l0aFNlbGVjdGlvbigKKyAgICAgICAgV2ViU3Ry aW5nJiB0ZXh0LAorICAgICAgICBzaXplX3QmIGZvY3VzLAorICAgICAgICBzaXplX3QmIGFuY2hv cikgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KKwogICAgIC8vIFJldHVybnMgdGhlIGN1cnJlbnQg Y2FyZXQgYm91bmRzIG9mIHRoaXMgV2ViV2lkZ2V0LiBUaGUgc2VsZWN0aW9uIGJvdW5kcwogICAg IC8vIHdpbGwgYmUgcmV0dXJuZWQgaWYgYSBzZWxlY3Rpb24gcmFuZ2UgaXMgYXZhaWxhYmxlLgog ICAgIHZpcnR1YWwgV2ViUmVjdCBjYXJldE9yU2VsZWN0aW9uQm91bmRzKCkgeyByZXR1cm4gV2Vi UmVjdCgpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3 SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKaW5k ZXggNWQzZmQ3YWVjMGVlNWQ4ZTAyZmQ4ZThiNzBhODA5ZmFmNGQwNmEwYS4uMDIyN2NmYzM2NGVj YTFiNTVjNWIxZDJlYzA3M2U4NDNlYzhmYjg2MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYlZpZXdJbXBsLmNwcApAQCAtMTUwOCw2ICsxNTA4LDU3IEBAIFdlYlRleHRJbnB1dFR5 cGUgV2ViVmlld0ltcGw6OnRleHRJbnB1dFR5cGUoKQogICAgIHJldHVybiBXZWJUZXh0SW5wdXRU eXBlTm9uZTsKIH0KIAorYm9vbCBXZWJWaWV3SW1wbDo6c3Vycm91bmRpbmdUZXh0V2l0aFNlbGVj dGlvbigKKyAgICBXZWJTdHJpbmcmIHRleHQsIHNpemVfdCYgZm9jdXMsIHNpemVfdCYgYW5jaG9y KSBjb25zdAoreworICAgIGNvbnN0IEZyYW1lKiBmcmFtZSA9IGZvY3VzZWRXZWJDb3JlRnJhbWUo KTsKKyAgICBpZiAoIWZyYW1lKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBjb25zdCBG cmFtZVNlbGVjdGlvbiogc2VsZWN0aW9uID0gZnJhbWUtPnNlbGVjdGlvbigpOworICAgIGlmICgh c2VsZWN0aW9uLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisK KyAgICBpZiAoc2VsZWN0aW9uLT5iYXNlKCkuY29udGFpbmVyTm9kZSgpID09IHNlbGVjdGlvbi0+ ZXh0ZW50KCkuY29udGFpbmVyTm9kZSgpKSB7CisgICAgICAgIC8vIEluIG1vc3QgY2FzZSBmb2N1 cyBhbmQgYW5jaG9yIGFyZSBpbiB0aGUgc2FtZSBlbGVtZW50LiBXZSBnZXQgdGhlCisgICAgICAg IC8vIHRleHQgZnJvbSB0aGlzIGVsZW1lbnQuCisgICAgICAgIE5vZGUqIG5vZGUgPSBzZWxlY3Rp b24tPmJhc2UoKS5jb250YWluZXJOb2RlKCk7CisgICAgICAgIGlmICghbm9kZSB8fCAhbm9kZS0+ aXNFbGVtZW50Tm9kZSgpKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICBFbGVt ZW50KiBlbGVtZW50ID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KHNlbGVjdGlvbi0+YmFzZSgpLmNv bnRhaW5lck5vZGUoKSk7CisgICAgICAgIHRleHQgPSBlbGVtZW50LT5pbm5lclRleHQoKTsKKyAg ICAgICAgZm9jdXMgPSBzZWxlY3Rpb24tPmJhc2UoKS5jb21wdXRlT2Zmc2V0SW5Db250YWluZXJO b2RlKCk7CisgICAgICAgIGFuY2hvciA9IHNlbGVjdGlvbi0+ZXh0ZW50KCkuY29tcHV0ZU9mZnNl dEluQ29udGFpbmVyTm9kZSgpOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgICAv LyBJZiBmb2N1cyBhbmQgYW5jaG9yIGFyZSBpbiBkaWZmZXJlbnQgbm9kZXMsIHdlIHdpbGwgZ2V0 IHRoZSB0ZXh0IGZyb20KKyAgICAvLyB0aGUgcm9vdCBlZGl0YWJsZSBlbGVtZW50LgorICAgIC8v IEZJWE1FOiBGaW5kIHRoZSBzbWFsbGVyIHNjb3BlIHdoaWNoIGNhbiBjb252ZXIgdGhlIGZvY3Vz IGFuZCBhbmNob3IKKyAgICAvLyBpbnN0ZWFkIG9mIHRoZSByb290IGVkaXRhYmxlIGVsZW1lbnQu CisgICAgc2l6ZV90IGxvY2F0aW9uOworICAgIHNpemVfdCBsZW5ndGg7CisgICAgUmVmUHRyPFJh bmdlPiByYW5nZSA9IHNlbGVjdGlvbi0+c2VsZWN0aW9uKCkuZmlyc3RSYW5nZSgpOworICAgIGlm ICghcmFuZ2UuZ2V0KCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmICghVGV4dEl0 ZXJhdG9yOjpsb2NhdGlvbkFuZExlbmd0aEZyb21SYW5nZShyYW5nZS5nZXQoKSwgbG9jYXRpb24s IGxlbmd0aCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmIChzZWxlY3Rpb24tPnNl bGVjdGlvbigpLmlzQmFzZUZpcnN0KCkpIHsKKyAgICAgICAgYW5jaG9yID0gbG9jYXRpb247Cisg ICAgICAgIGZvY3VzID0gbG9jYXRpb24gKyBsZW5ndGg7CisgICAgfSBlbHNlIHsKKyAgICAgICAg Zm9jdXMgPSBsb2NhdGlvbjsKKyAgICAgICAgYW5jaG9yID0gbG9jYXRpb24gKyBsZW5ndGg7Cisg ICAgfQorCisgICAgRWxlbWVudCogZWxlbWVudCA9IHNlbGVjdGlvbi0+cm9vdEVkaXRhYmxlRWxl bWVudCgpOworICAgIHRleHQgPSBlbGVtZW50LT5pbm5lclRleHQoKTsKKworICAgIHJldHVybiB0 cnVlOworfQorCiBXZWJSZWN0IFdlYlZpZXdJbXBsOjpjYXJldE9yU2VsZWN0aW9uQm91bmRzKCkK IHsKICAgICBXZWJSZWN0IHJlY3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJWaWV3SW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0lt cGwuaAppbmRleCAwMWZjOTEwNWMwZGY3NmE0NmM1ZTFjMGQyYjU3MzMzZWRmYTMzMzdkLi5jMjdj ZmQwNGMwMmIzNjdkY2RlZjQ5MjBlNmMxNzdhYTJlYWEwOGQ1IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKQEAgLTExNyw2ICsxMTcsMTAgQEAgcHVibGljOgogICAg IHZpcnR1YWwgYm9vbCBjb25maXJtQ29tcG9zaXRpb24oY29uc3QgV2ViU3RyaW5nJiB0ZXh0KTsK ICAgICB2aXJ0dWFsIGJvb2wgY29tcG9zaXRpb25SYW5nZShzaXplX3QqIGxvY2F0aW9uLCBzaXpl X3QqIGxlbmd0aCk7CiAgICAgdmlydHVhbCBXZWJUZXh0SW5wdXRUeXBlIHRleHRJbnB1dFR5cGUo KTsKKyAgICB2aXJ0dWFsIGJvb2wgc3Vycm91bmRpbmdUZXh0V2l0aFNlbGVjdGlvbigKKyAgICAg ICAgV2ViU3RyaW5nJiB0ZXh0LAorICAgICAgICBzaXplX3QmIGZvY3VzLAorICAgICAgICBzaXpl X3QmIGFuY2hvcikgY29uc3Q7CiAgICAgdmlydHVhbCBXZWJSZWN0IGNhcmV0T3JTZWxlY3Rpb25C b3VuZHMoKTsKICAgICB2aXJ0dWFsIGJvb2wgc2VsZWN0aW9uUmFuZ2UoV2ViUG9pbnQmIHN0YXJ0 LCBXZWJQb2ludCYgZW5kKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgY2FyZXRPclNlbGVjdGlv blJhbmdlKHNpemVfdCogbG9jYXRpb24sIHNpemVfdCogbGVuZ3RoKTsK 106046 2011-09-01 15:22:07 -0700 2011-09-01 16:32:36 -0700 Patch bug-66681-20110901182202.patch text/plain 4172 penghuang U3VidmVyc2lvbiBSZXZpc2lvbjogOTQzNDAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXgg NDJjYTcyNzFmOTEwN2I2YWQ3YjMzODc3MDVjNTY5NTkxNjlkMTVmNy4uNWM5ZTlkNTliMjNkYjM3 ZTg2NzMxMDYwNDdhZGFjNmY0ZjgxMjk3NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxNiBAQAorMjAxMS0wOS0wMSAgUGVuZyBIdWFuZyAgPHBlbmdodWFuZ0BjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cnJvdW5kaW5nVGV4dFdpdGhTZWxlY3Rpb24oKSB0byBD aHJvbWl1bSdzIFdlYlZpZXdJbXBsCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD02NjY4MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgICogcHVibGljL1dlYldpZGdldC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJX aWRnZXQ6OnN1cnJvdW5kaW5nVGV4dFdpdGhTZWxlY3Rpb24pOgorICAgICAgICAqIHNyYy9XZWJW aWV3SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBsOjpzdXJyb3VuZGluZ1Rl eHRXaXRoU2VsZWN0aW9uKToKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuaDoKKwogMjAxMS0w OC0zMSAgR3JlZyBCaWxsb2NrICA8Z2JpbGxvY2tAZ29vZ2xlLmNvbT4KIAogICAgICAgICBBZGQg cGFzcy10aHJvdWdocyBmb3IgTlBPYmplY3Qvdjg6OlZhbHVlIG1hcnNoYWxsaW5nIHRvIFdlYkJp bmRpbmdzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJXaWRn ZXQuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYldpZGdldC5oCmluZGV4IDFi YzE5MWNjMzViZjc2OTAwOTBiMDgwZjhiYTk2N2FjNGFlMzg5MzMuLmRjMWQzYjUzNmYyZDhlM2Ex NGFhMzNmMjMwNDYxNTY0OTc0N2U0NDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYldpZGdldC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGlj L1dlYldpZGdldC5oCkBAIC0xNDcsNiArMTQ3LDE1IEBAIHB1YmxpYzoKICAgICAvLyBSZXR1cm5z IHRoZSBjdXJyZW50IHRleHQgaW5wdXQgdHlwZSBvZiB0aGlzIFdlYldpZGdldC4KICAgICB2aXJ0 dWFsIFdlYlRleHRJbnB1dFR5cGUgdGV4dElucHV0VHlwZSgpIHsgcmV0dXJuIFdlYktpdDo6V2Vi VGV4dElucHV0VHlwZU5vbmU7IH0KIAorICAgIC8vIFJldHVybnMgdGhlIHBsYWluIHRleHQgYXJv dW5kIHRoZSBpbnB1dCBhcmVhLCBmb3IgZXhhbXBsZSB0aGUgY3VycmVudAorICAgIC8vIHBhcmFn cmFwaC4gVGhlIGZvY3VzIGlzIHRoZSBpbmRleCBvZiB0aGUgaW5wdXQgY3Vyc29yIGluIHRoZSB0 ZXh0LgorICAgIC8vIFRoZSBhbmNob3IgaXMgdGhlIGluZGV4IG9mIHRoZSBzZWxlY3Rpb24gYW5j aG9yIGluIHRoZSB0ZXh0LiBJZiB0aGVyZSBpcworICAgIC8vIG5vIHNlbGVjdGlvbiwgZm9jdXMg YW5kIGFuY2hvciBhcmUgc2FtZS4KKyAgICB2aXJ0dWFsIGJvb2wgc3Vycm91bmRpbmdUZXh0V2l0 aFNlbGVjdGlvbigKKyAgICAgICAgV2ViU3RyaW5nJiB0ZXh0LAorICAgICAgICBzaXplX3QmIGZv Y3VzLAorICAgICAgICBzaXplX3QmIGFuY2hvcikgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KKwog ICAgIC8vIFJldHVybnMgdGhlIGN1cnJlbnQgY2FyZXQgYm91bmRzIG9mIHRoaXMgV2ViV2lkZ2V0 LiBUaGUgc2VsZWN0aW9uIGJvdW5kcwogICAgIC8vIHdpbGwgYmUgcmV0dXJuZWQgaWYgYSBzZWxl Y3Rpb24gcmFuZ2UgaXMgYXZhaWxhYmxlLgogICAgIHZpcnR1YWwgV2ViUmVjdCBjYXJldE9yU2Vs ZWN0aW9uQm91bmRzKCkgeyByZXR1cm4gV2ViUmVjdCgpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKaW5kZXggNWQzZmQ3YWVjMGVlNWQ4ZTAyZmQ4ZThiNzBh ODA5ZmFmNGQwNmEwYS4uYmE2MDhiM2Q0N2UyOTg2ZGVmNDE5NDNjNjk5ZjdhZjc0NjZiYWY4NCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisr KyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcApAQCAtMTUwOCw2 ICsxNTA4LDQwIEBAIFdlYlRleHRJbnB1dFR5cGUgV2ViVmlld0ltcGw6OnRleHRJbnB1dFR5cGUo KQogICAgIHJldHVybiBXZWJUZXh0SW5wdXRUeXBlTm9uZTsKIH0KIAorYm9vbCBXZWJWaWV3SW1w bDo6c3Vycm91bmRpbmdUZXh0V2l0aFNlbGVjdGlvbigKKyAgICBXZWJTdHJpbmcmIHRleHQsIHNp emVfdCYgZm9jdXMsIHNpemVfdCYgYW5jaG9yKSBjb25zdAoreworICAgIGNvbnN0IEZyYW1lKiBm cmFtZSA9IGZvY3VzZWRXZWJDb3JlRnJhbWUoKTsKKyAgICBpZiAoIWZyYW1lKQorICAgICAgICBy ZXR1cm4gZmFsc2U7CisKKyAgICBjb25zdCBGcmFtZVNlbGVjdGlvbiogc2VsZWN0aW9uID0gZnJh bWUtPnNlbGVjdGlvbigpOworICAgIGlmICghc2VsZWN0aW9uLT5pc0NvbnRlbnRFZGl0YWJsZSgp KQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBFbGVtZW50KiBlbGVtZW50ID0gc2VsZWN0 aW9uLT5yb290RWRpdGFibGVFbGVtZW50KCk7CisgICAgdGV4dCA9IGVsZW1lbnQtPmlubmVyVGV4 dCgpOworCisgICAgc2l6ZV90IGxvY2F0aW9uOworICAgIHNpemVfdCBsZW5ndGg7CisgICAgUmVm UHRyPFJhbmdlPiByYW5nZSA9IHNlbGVjdGlvbi0+c2VsZWN0aW9uKCkuZmlyc3RSYW5nZSgpOwor ICAgIGlmICghcmFuZ2UuZ2V0KCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmICgh VGV4dEl0ZXJhdG9yOjpsb2NhdGlvbkFuZExlbmd0aEZyb21SYW5nZShyYW5nZS5nZXQoKSwgbG9j YXRpb24sIGxlbmd0aCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmIChzZWxlY3Rp b24tPnNlbGVjdGlvbigpLmlzQmFzZUZpcnN0KCkpIHsKKyAgICAgICAgYW5jaG9yID0gbG9jYXRp b247CisgICAgICAgIGZvY3VzID0gbG9jYXRpb24gKyBsZW5ndGg7CisgICAgfSBlbHNlIHsKKyAg ICAgICAgZm9jdXMgPSBsb2NhdGlvbjsKKyAgICAgICAgYW5jaG9yID0gbG9jYXRpb24gKyBsZW5n dGg7CisgICAgfQorCisgICAgcmV0dXJuIHRydWU7Cit9CisKIFdlYlJlY3QgV2ViVmlld0ltcGw6 OmNhcmV0T3JTZWxlY3Rpb25Cb3VuZHMoKQogewogICAgIFdlYlJlY3QgcmVjdDsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmggYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCmluZGV4IDAxZmM5MTA1YzBkZjc2YTQ2YzVl MWMwZDJiNTczMzNlZGZhMzMzN2QuLmMyN2NmZDA0YzAyYjM2N2RjZGVmNDkyMGU2YzE3N2FhMmVh YTA4ZDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBs LmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaApAQCAtMTE3 LDYgKzExNywxMCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBib29sIGNvbmZpcm1Db21wb3NpdGlv bihjb25zdCBXZWJTdHJpbmcmIHRleHQpOwogICAgIHZpcnR1YWwgYm9vbCBjb21wb3NpdGlvblJh bmdlKHNpemVfdCogbG9jYXRpb24sIHNpemVfdCogbGVuZ3RoKTsKICAgICB2aXJ0dWFsIFdlYlRl eHRJbnB1dFR5cGUgdGV4dElucHV0VHlwZSgpOworICAgIHZpcnR1YWwgYm9vbCBzdXJyb3VuZGlu Z1RleHRXaXRoU2VsZWN0aW9uKAorICAgICAgICBXZWJTdHJpbmcmIHRleHQsCisgICAgICAgIHNp emVfdCYgZm9jdXMsCisgICAgICAgIHNpemVfdCYgYW5jaG9yKSBjb25zdDsKICAgICB2aXJ0dWFs IFdlYlJlY3QgY2FyZXRPclNlbGVjdGlvbkJvdW5kcygpOwogICAgIHZpcnR1YWwgYm9vbCBzZWxl Y3Rpb25SYW5nZShXZWJQb2ludCYgc3RhcnQsIFdlYlBvaW50JiBlbmQpIGNvbnN0OwogICAgIHZp cnR1YWwgYm9vbCBjYXJldE9yU2VsZWN0aW9uUmFuZ2Uoc2l6ZV90KiBsb2NhdGlvbiwgc2l6ZV90 KiBsZW5ndGgpOwo= 106061 2011-09-01 16:32:44 -0700 2011-09-02 12:30:29 -0700 Patch bug-66681-20110901193239.patch text/plain 4117 penghuang U3VidmVyc2lvbiBSZXZpc2lvbjogOTQzNDAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXgg NDJjYTcyNzFmOTEwN2I2YWQ3YjMzODc3MDVjNTY5NTkxNjlkMTVmNy4uNWU3ZDJjNmJhNGM3MzEy MzhiZWFjMDM2ZWMyZWE3MDU5YjllZjhkYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxOCBAQAorMjAxMS0wOS0wMSAgUGVuZyBIdWFuZyAgPHBlbmdodWFuZ0BjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgTmVlZCBBUEkgZm9yIGdldHRpbmcgc3Vycm91bmRpbmcgdGV4dCBm cm9tIHdlYmtpdCBpbiBjaHJvbWl1bQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NjY2ODEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBBZGQgc3Vycm91bmRpbmdUZXh0V2l0aFNlbGVjdGlvbigpIHRvIENocm9t aXVtJ3MgV2ViVmlld0ltcGwKKworICAgICAgICAqIHB1YmxpYy9XZWJXaWRnZXQuaDoKKyAgICAg ICAgKFdlYktpdDo6V2ViV2lkZ2V0OjpzdXJyb3VuZGluZ1RleHRXaXRoU2VsZWN0aW9uKToKKyAg ICAgICAgKiBzcmMvV2ViVmlld0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1w bDo6c3Vycm91bmRpbmdUZXh0V2l0aFNlbGVjdGlvbik6CisgICAgICAgICogc3JjL1dlYlZpZXdJ bXBsLmg6CisKIDIwMTEtMDgtMzEgIEdyZWcgQmlsbG9jayAgPGdiaWxsb2NrQGdvb2dsZS5jb20+ CiAKICAgICAgICAgQWRkIHBhc3MtdGhyb3VnaHMgZm9yIE5QT2JqZWN0L3Y4OjpWYWx1ZSBtYXJz aGFsbGluZyB0byBXZWJCaW5kaW5ncwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9wdWJsaWMvV2ViV2lkZ2V0LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJX aWRnZXQuaAppbmRleCAxYmMxOTFjYzM1YmY3NjkwMDkwYjA4MGY4YmE5NjdhYzRhZTM4OTMzLi5j NTkyZTY5ZjQ3MTQ4MjkzNGQ0NzE3MDM5ODhmM2FmMTljZjA1NzAzIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJXaWRnZXQuaAorKysgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9XZWJXaWRnZXQuaApAQCAtMTQ3LDYgKzE0NywxMiBAQCBwdWJsaWM6 CiAgICAgLy8gUmV0dXJucyB0aGUgY3VycmVudCB0ZXh0IGlucHV0IHR5cGUgb2YgdGhpcyBXZWJX aWRnZXQuCiAgICAgdmlydHVhbCBXZWJUZXh0SW5wdXRUeXBlIHRleHRJbnB1dFR5cGUoKSB7IHJl dHVybiBXZWJLaXQ6OldlYlRleHRJbnB1dFR5cGVOb25lOyB9CiAKKyAgICAvLyBSZXR1cm5zIHRo ZSBwbGFpbiB0ZXh0IGFyb3VuZCB0aGUgaW5wdXQgYXJlYSwgZm9yIGV4YW1wbGUgdGhlIGN1cnJl bnQKKyAgICAvLyBwYXJhZ3JhcGguIFRoZSBmb2N1cyBpcyB0aGUgaW5kZXggb2YgdGhlIGlucHV0 IGN1cnNvciBpbiB0aGUgdGV4dC4KKyAgICAvLyBUaGUgYW5jaG9yIGlzIHRoZSBpbmRleCBvZiB0 aGUgc2VsZWN0aW9uIGFuY2hvciBpbiB0aGUgdGV4dC4gSWYgdGhlcmUgaXMKKyAgICAvLyBubyBz ZWxlY3Rpb24sIGZvY3VzIGFuZCBhbmNob3IgYXJlIHNhbWUuCisgICAgdmlydHVhbCBib29sIHN1 cnJvdW5kaW5nVGV4dFdpdGhTZWxlY3Rpb24oV2ViU3RyaW5nJiwgc2l6ZV90JiBmb2N1cywgc2l6 ZV90JiBhbmNob3IpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CisKICAgICAvLyBSZXR1cm5zIHRo ZSBjdXJyZW50IGNhcmV0IGJvdW5kcyBvZiB0aGlzIFdlYldpZGdldC4gVGhlIHNlbGVjdGlvbiBi b3VuZHMKICAgICAvLyB3aWxsIGJlIHJldHVybmVkIGlmIGEgc2VsZWN0aW9uIHJhbmdlIGlzIGF2 YWlsYWJsZS4KICAgICB2aXJ0dWFsIFdlYlJlY3QgY2FyZXRPclNlbGVjdGlvbkJvdW5kcygpIHsg cmV0dXJuIFdlYlJlY3QoKTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViVmlld0ltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0lt cGwuY3BwCmluZGV4IDVkM2ZkN2FlYzBlZTVkOGUwMmZkOGU4YjcwYTgwOWZhZjRkMDZhMGEuLjYw NjkyNjY2MTAyODA3MDQ2MTc1M2UzNjdlMWNjYTA0ZTg0ZjFjYjQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTE1MDgsNiArMTUwOCwzNyBAQCBXZWJU ZXh0SW5wdXRUeXBlIFdlYlZpZXdJbXBsOjp0ZXh0SW5wdXRUeXBlKCkKICAgICByZXR1cm4gV2Vi VGV4dElucHV0VHlwZU5vbmU7CiB9CiAKK2Jvb2wgV2ViVmlld0ltcGw6OnN1cnJvdW5kaW5nVGV4 dFdpdGhTZWxlY3Rpb24oCisgICAgV2ViU3RyaW5nJiB0ZXh0LCBzaXplX3QmIGZvY3VzLCBzaXpl X3QmIGFuY2hvcikgY29uc3QKK3sKKyAgICBjb25zdCBGcmFtZSogZnJhbWUgPSBmb2N1c2VkV2Vi Q29yZUZyYW1lKCk7CisgICAgaWYgKCFmcmFtZSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisg ICAgY29uc3QgRnJhbWVTZWxlY3Rpb24qIHNlbGVjdGlvbiA9IGZyYW1lLT5zZWxlY3Rpb24oKTsK KyAgICBFbGVtZW50KiBlbGVtZW50ID0gc2VsZWN0aW9uLT5yb290RWRpdGFibGVFbGVtZW50KCk7 CisgICAgaWYgKCFlbGVtZW50KQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICB0ZXh0ID0g ZWxlbWVudC0+aW5uZXJUZXh0KCk7CisKKyAgICBzaXplX3QgbG9jYXRpb247CisgICAgc2l6ZV90 IGxlbmd0aDsKKyAgICBSZWZQdHI8UmFuZ2U+IHJhbmdlID0gc2VsZWN0aW9uLT5zZWxlY3Rpb24o KS5maXJzdFJhbmdlKCk7CisgICAgaWYgKCFyYW5nZSB8fCAhVGV4dEl0ZXJhdG9yOjpsb2NhdGlv bkFuZExlbmd0aEZyb21SYW5nZShyYW5nZS5nZXQoKSwgbG9jYXRpb24sIGxlbmd0aCkpCisgICAg ICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmIChzZWxlY3Rpb24tPnNlbGVjdGlvbigpLmlzQmFz ZUZpcnN0KCkpIHsKKyAgICAgICAgYW5jaG9yID0gbG9jYXRpb247CisgICAgICAgIGZvY3VzID0g bG9jYXRpb24gKyBsZW5ndGg7CisgICAgfSBlbHNlIHsKKyAgICAgICAgZm9jdXMgPSBsb2NhdGlv bjsKKyAgICAgICAgYW5jaG9yID0gbG9jYXRpb24gKyBsZW5ndGg7CisgICAgfQorCisgICAgcmV0 dXJuIHRydWU7Cit9CisKIFdlYlJlY3QgV2ViVmlld0ltcGw6OmNhcmV0T3JTZWxlY3Rpb25Cb3Vu ZHMoKQogewogICAgIFdlYlJlY3QgcmVjdDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYlZpZXdJbXBsLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJW aWV3SW1wbC5oCmluZGV4IDAxZmM5MTA1YzBkZjc2YTQ2YzVlMWMwZDJiNTczMzNlZGZhMzMzN2Qu LjNhYWQxMWU3ZmMxYTg5NzY5NWNmZTdhNjJjMDg5YzQ4ZWQ5NjFkMTAgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKKysrIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaApAQCAtMTE3LDYgKzExNyw3IEBAIHB1YmxpYzoK ICAgICB2aXJ0dWFsIGJvb2wgY29uZmlybUNvbXBvc2l0aW9uKGNvbnN0IFdlYlN0cmluZyYgdGV4 dCk7CiAgICAgdmlydHVhbCBib29sIGNvbXBvc2l0aW9uUmFuZ2Uoc2l6ZV90KiBsb2NhdGlvbiwg c2l6ZV90KiBsZW5ndGgpOwogICAgIHZpcnR1YWwgV2ViVGV4dElucHV0VHlwZSB0ZXh0SW5wdXRU eXBlKCk7CisgICAgdmlydHVhbCBib29sIHN1cnJvdW5kaW5nVGV4dFdpdGhTZWxlY3Rpb24oV2Vi U3RyaW5nJiwgc2l6ZV90JiBmb2N1cywgc2l6ZV90JiBhbmNob3IpIGNvbnN0OwogICAgIHZpcnR1 YWwgV2ViUmVjdCBjYXJldE9yU2VsZWN0aW9uQm91bmRzKCk7CiAgICAgdmlydHVhbCBib29sIHNl bGVjdGlvblJhbmdlKFdlYlBvaW50JiBzdGFydCwgV2ViUG9pbnQmIGVuZCkgY29uc3Q7CiAgICAg dmlydHVhbCBib29sIGNhcmV0T3JTZWxlY3Rpb25SYW5nZShzaXplX3QqIGxvY2F0aW9uLCBzaXpl X3QqIGxlbmd0aCk7Cg== 106175 2011-09-02 12:30:38 -0700 2011-09-02 13:53:05 -0700 Patch bug-66681-20110902153030.patch text/plain 4094 penghuang U3VidmVyc2lvbiBSZXZpc2lvbjogOTQ0MzAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXgg MTEyZjBkZjlhZWMxZDkyYTJmZjA0YzRhYmMyNTkzMmRiMzc0MTc0MC4uYmQ5MWU5OTg0MmQ5YmRh OGVlMTM5NmJlZWI1MmFlM2Y5NTVmNjQ4YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwyMCBAQAorMjAxMS0wOS0wMiAgUGVuZyBIdWFuZyAgPHBlbmdodWFuZ0BjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgTmVlZCBBUEkgZm9yIGdldHRpbmcgc3Vycm91bmRpbmcgdGV4dCBm cm9tIHdlYmtpdCBpbiBjaHJvbWl1bQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NjY2ODEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBBZGQgZ2V0VGV4dFN1cnJvdW5kRWRpdENhcmV0KCkgdG8gQ2hyb21pdW0n cyBXZWJWaWV3SW1wbC4gVGhpcyBmdW5jdGlvbgorICAgICAgICBpcyBmb3Igc3VwcG9ydGluZyBz b21lIGlucHV0IG1ldGhvZHMgd2hpY2ggbmVlZCBpbnB1dCBjb250ZXh0IGFyb3VuZAorICAgICAg ICB0aGUgZWRpdCBjYXJldC4KKworICAgICAgICAqIHB1YmxpYy9XZWJXaWRnZXQuaDoKKyAgICAg ICAgKFdlYktpdDo6V2ViV2lkZ2V0OjpzdXJyb3VuZGluZ1RleHRXaXRoU2VsZWN0aW9uKToKKyAg ICAgICAgKiBzcmMvV2ViVmlld0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1w bDo6c3Vycm91bmRpbmdUZXh0V2l0aFNlbGVjdGlvbik6CisgICAgICAgICogc3JjL1dlYlZpZXdJ bXBsLmg6CisKIDIwMTEtMDktMDEgIFJvYmVydCBLcm9lZ2VyICA8cmprcm9lZ2VAY2hyb21pdW0u b3JnPgogCiAgCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJX aWRnZXQuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYldpZGdldC5oCmluZGV4 IDFiYzE5MWNjMzViZjc2OTAwOTBiMDgwZjhiYTk2N2FjNGFlMzg5MzMuLmRiYTYzMWNmZWI3NWI3 ODlhNjgzZDFlYjYzMTI4NjRmMzkxMjFkOWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vcHVibGljL1dlYldpZGdldC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYldpZGdldC5oCkBAIC0xNDcsNiArMTQ3LDExIEBAIHB1YmxpYzoKICAgICAvLyBSZXR1 cm5zIHRoZSBjdXJyZW50IHRleHQgaW5wdXQgdHlwZSBvZiB0aGlzIFdlYldpZGdldC4KICAgICB2 aXJ0dWFsIFdlYlRleHRJbnB1dFR5cGUgdGV4dElucHV0VHlwZSgpIHsgcmV0dXJuIFdlYktpdDo6 V2ViVGV4dElucHV0VHlwZU5vbmU7IH0KIAorICAgIC8vIFJldHVybnMgdGhlIHBsYWluIHRleHQg YXJvdW5kIHRoZSBlZGl0IGNhcmV0IGFuZCB0aGUgZm9jdXMgaW5kZXggaW4gdGhlCisgICAgLy8g dGV4dC4gSWYgc2VsZWN0aW9uIGV4aXN0cywgaXQgd2lsbCByZXR1cm4gdGhlIGFuY2hvciBpbmRl eCBhcyB3ZWxsLAorICAgIC8vIG90aGVyd2lzZSB0aGUgYW5jaG9yIGluZGV4IHdpbGwgYmUgdGhl IHNhbWUgdmFsdWUgb2YgdGhlIGZvY3VzIGluZGV4LgorICAgIHZpcnR1YWwgYm9vbCBnZXRUZXh0 U3Vycm91bmRFZGl0Q2FyZXQoV2ViU3RyaW5nJiwgc2l6ZV90JiBmb2N1cywgc2l6ZV90JiBhbmNo b3IpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CisKICAgICAvLyBSZXR1cm5zIHRoZSBjdXJyZW50 IGNhcmV0IGJvdW5kcyBvZiB0aGlzIFdlYldpZGdldC4gVGhlIHNlbGVjdGlvbiBib3VuZHMKICAg ICAvLyB3aWxsIGJlIHJldHVybmVkIGlmIGEgc2VsZWN0aW9uIHJhbmdlIGlzIGF2YWlsYWJsZS4K ICAgICB2aXJ0dWFsIFdlYlJlY3QgY2FyZXRPclNlbGVjdGlvbkJvdW5kcygpIHsgcmV0dXJuIFdl YlJlY3QoKTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmll d0ltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmlu ZGV4IDljM2RkODQwNjJmYjYwMmY0MjcwOTMwNThlY2RhODNhYTQxNWYzM2EuLmFhODU5YTg0YjYy YzNhZTUxZjVhNGE3MDkzNTBmMWQwNDE5OThjYmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTE1MDgsNiArMTUwOCwzNiBAQCBXZWJUZXh0SW5wdXRU eXBlIFdlYlZpZXdJbXBsOjp0ZXh0SW5wdXRUeXBlKCkKICAgICByZXR1cm4gV2ViVGV4dElucHV0 VHlwZU5vbmU7CiB9CiAKK2Jvb2wgV2ViVmlld0ltcGw6OmdldFRleHRTdXJyb3VuZEVkaXRDYXJl dChXZWJTdHJpbmcmIHRleHQsIHNpemVfdCYgZm9jdXMsIHNpemVfdCYgYW5jaG9yKSBjb25zdAor eworICAgIGNvbnN0IEZyYW1lKiBmcmFtZSA9IGZvY3VzZWRXZWJDb3JlRnJhbWUoKTsKKyAgICBp ZiAoIWZyYW1lKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBjb25zdCBGcmFtZVNlbGVj dGlvbiogc2VsZWN0aW9uID0gZnJhbWUtPnNlbGVjdGlvbigpOworICAgIEVsZW1lbnQqIGVsZW1l bnQgPSBzZWxlY3Rpb24tPnJvb3RFZGl0YWJsZUVsZW1lbnQoKTsKKyAgICBpZiAoIWVsZW1lbnQp CisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIHNpemVfdCBsb2NhdGlvbjsKKyAgICBzaXpl X3QgbGVuZ3RoOworICAgIFJlZlB0cjxSYW5nZT4gcmFuZ2UgPSBzZWxlY3Rpb24tPnNlbGVjdGlv bigpLmZpcnN0UmFuZ2UoKTsKKyAgICBpZiAoIXJhbmdlIHx8ICFUZXh0SXRlcmF0b3I6OmxvY2F0 aW9uQW5kTGVuZ3RoRnJvbVJhbmdlKHJhbmdlLmdldCgpLCBsb2NhdGlvbiwgbGVuZ3RoKSkKKyAg ICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKHNlbGVjdGlvbi0+c2VsZWN0aW9uKCkuaXNC YXNlRmlyc3QoKSkgeworICAgICAgICBhbmNob3IgPSBsb2NhdGlvbjsKKyAgICAgICAgZm9jdXMg PSBsb2NhdGlvbiArIGxlbmd0aDsKKyAgICB9IGVsc2UgeworICAgICAgICBhbmNob3IgPSBsb2Nh dGlvbjsKKyAgICAgICAgZm9jdXMgPSBsb2NhdGlvbiArIGxlbmd0aDsKKyAgICB9CisKKyAgICB0 ZXh0ID0gZWxlbWVudC0+aW5uZXJUZXh0KCk7CisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogV2Vi UmVjdCBXZWJWaWV3SW1wbDo6Y2FyZXRPclNlbGVjdGlvbkJvdW5kcygpCiB7CiAgICAgV2ViUmVj dCByZWN0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0lt cGwuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKaW5kZXggMDFm YzkxMDVjMGRmNzZhNDZjNWUxYzBkMmI1NzMzM2VkZmEzMzM3ZC4uNDc4ZjdjODg1MzlkZGEzYmVi MGNkMjJhZmJiZDViNTY5YjYwNmU2YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViVmlld0ltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJW aWV3SW1wbC5oCkBAIC0xMTcsNiArMTE3LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBj b25maXJtQ29tcG9zaXRpb24oY29uc3QgV2ViU3RyaW5nJiB0ZXh0KTsKICAgICB2aXJ0dWFsIGJv b2wgY29tcG9zaXRpb25SYW5nZShzaXplX3QqIGxvY2F0aW9uLCBzaXplX3QqIGxlbmd0aCk7CiAg ICAgdmlydHVhbCBXZWJUZXh0SW5wdXRUeXBlIHRleHRJbnB1dFR5cGUoKTsKKyAgICB2aXJ0dWFs IGJvb2wgZ2V0VGV4dFN1cnJvdW5kRWRpdENhcmV0KFdlYlN0cmluZyYsIHNpemVfdCYgZm9jdXMs IHNpemVfdCYgYW5jaG9yKSBjb25zdDsKICAgICB2aXJ0dWFsIFdlYlJlY3QgY2FyZXRPclNlbGVj dGlvbkJvdW5kcygpOwogICAgIHZpcnR1YWwgYm9vbCBzZWxlY3Rpb25SYW5nZShXZWJQb2ludCYg c3RhcnQsIFdlYlBvaW50JiBlbmQpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBjYXJldE9yU2Vs ZWN0aW9uUmFuZ2Uoc2l6ZV90KiBsb2NhdGlvbiwgc2l6ZV90KiBsZW5ndGgpOwo= 106189 2011-09-02 13:53:14 -0700 2011-09-02 16:06:34 -0700 Patch bug-66681-20110902165306.patch text/plain 4200 penghuang U3VidmVyc2lvbiBSZXZpc2lvbjogOTQ0MzAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXgg MTEyZjBkZjlhZWMxZDkyYTJmZjA0YzRhYmMyNTkzMmRiMzc0MTc0MC4uYzk4ZWIzZjE2NTU3MTY3 NjgyOTIxMGZmM2NiNWE5MGJhMjNhODAzMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwyMCBAQAorMjAxMS0wOS0wMiAgUGVuZyBIdWFuZyAgPHBlbmdodWFuZ0BjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgTmVlZCBBUEkgZm9yIGdldHRpbmcgc3Vycm91bmRpbmcgdGV4dCBm cm9tIHdlYmtpdCBpbiBjaHJvbWl1bQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NjY2ODEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBBZGQgZ2V0U2VsZWN0aW9uT2Zmc2V0c0FuZFRleHRJbkVkaXRhYmxlQ29u dGVudCgpIHRvIENocm9taXVtJ3MKKyAgICAgICAgV2ViVmlld0ltcGwuIFRoaXMgZnVuY3Rpb24g aXMgZm9yIHN1cHBvcnRpbmcgc29tZSBpbnB1dCBtZXRob2RzIHdoaWNoCisgICAgICAgIG5lZWQg aW5wdXQgY29udGV4dCBhcm91bmQgdGhlIGVkaXQgY2FyZXQuCisKKyAgICAgICAgKiBwdWJsaWMv V2ViV2lkZ2V0Lmg6CisgICAgICAgIChXZWJLaXQ6OldlYldpZGdldDo6Z2V0U2VsZWN0aW9uT2Zm c2V0c0FuZFRleHRJbkVkaXRhYmxlQ29udGVudCk6CisgICAgICAgICogc3JjL1dlYlZpZXdJbXBs LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6OmdldFNlbGVjdGlvbk9mZnNldHNB bmRUZXh0SW5FZGl0YWJsZUNvbnRlbnQpOgorICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5oOgor CiAyMDExLTA5LTAxICBSb2JlcnQgS3JvZWdlciAgPHJqa3JvZWdlQGNocm9taXVtLm9yZz4KIAog IApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViV2lkZ2V0Lmgg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJXaWRnZXQuaAppbmRleCAxYmMxOTFj YzM1YmY3NjkwMDkwYjA4MGY4YmE5NjdhYzRhZTM4OTMzLi43NDA3OTBiMzRlYTRmNjlmNTNkYWU3 YWJhMTIxNDQ3Y2U0MjhkMWEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1 YmxpYy9XZWJXaWRnZXQuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJX aWRnZXQuaApAQCAtMTQ3LDYgKzE0NywxMSBAQCBwdWJsaWM6CiAgICAgLy8gUmV0dXJucyB0aGUg Y3VycmVudCB0ZXh0IGlucHV0IHR5cGUgb2YgdGhpcyBXZWJXaWRnZXQuCiAgICAgdmlydHVhbCBX ZWJUZXh0SW5wdXRUeXBlIHRleHRJbnB1dFR5cGUoKSB7IHJldHVybiBXZWJLaXQ6OldlYlRleHRJ bnB1dFR5cGVOb25lOyB9CiAKKyAgICAvLyBSZXR1cm5zIHRoZSBwbGFpbiB0ZXh0IGFyb3VuZCB0 aGUgZWRpdCBjYXJldCBhbmQgdGhlIGZvY3VzIGluZGV4IGluIHRoZQorICAgIC8vIHRleHQuIElm IHNlbGVjdGlvbiBleGlzdHMsIGl0IHdpbGwgcmV0dXJuIHRoZSBhbmNob3IgaW5kZXggYXMgd2Vs bCwKKyAgICAvLyBvdGhlcndpc2UgdGhlIGFuY2hvciBpbmRleCB3aWxsIGJlIHRoZSBzYW1lIHZh bHVlIG9mIHRoZSBmb2N1cyBpbmRleC4KKyAgICB2aXJ0dWFsIGJvb2wgZ2V0U2VsZWN0aW9uT2Zm c2V0c0FuZFRleHRJbkVkaXRhYmxlQ29udGVudChXZWJTdHJpbmcmLCBzaXplX3QmIGZvY3VzLCBz aXplX3QmIGFuY2hvcikgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KKwogICAgIC8vIFJldHVybnMg dGhlIGN1cnJlbnQgY2FyZXQgYm91bmRzIG9mIHRoaXMgV2ViV2lkZ2V0LiBUaGUgc2VsZWN0aW9u IGJvdW5kcwogICAgIC8vIHdpbGwgYmUgcmV0dXJuZWQgaWYgYSBzZWxlY3Rpb24gcmFuZ2UgaXMg YXZhaWxhYmxlLgogICAgIHZpcnR1YWwgV2ViUmVjdCBjYXJldE9yU2VsZWN0aW9uQm91bmRzKCkg eyByZXR1cm4gV2ViUmVjdCgpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJWaWV3SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3 SW1wbC5jcHAKaW5kZXggOWMzZGQ4NDA2MmZiNjAyZjQyNzA5MzA1OGVjZGE4M2FhNDE1ZjMzYS4u YjNmYmE5YmJiMGFhMWIxYWQwYWQ4NjRhNzMxZTZkYTFkNDY2M2QzMyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcApAQCAtMTUwOCw2ICsxNTA4LDM2IEBAIFdl YlRleHRJbnB1dFR5cGUgV2ViVmlld0ltcGw6OnRleHRJbnB1dFR5cGUoKQogICAgIHJldHVybiBX ZWJUZXh0SW5wdXRUeXBlTm9uZTsKIH0KIAorYm9vbCBXZWJWaWV3SW1wbDo6Z2V0U2VsZWN0aW9u T2Zmc2V0c0FuZFRleHRJbkVkaXRhYmxlQ29udGVudChXZWJTdHJpbmcmIHRleHQsIHNpemVfdCYg Zm9jdXMsIHNpemVfdCYgYW5jaG9yKSBjb25zdAoreworICAgIGNvbnN0IEZyYW1lKiBmcmFtZSA9 IGZvY3VzZWRXZWJDb3JlRnJhbWUoKTsKKyAgICBpZiAoIWZyYW1lKQorICAgICAgICByZXR1cm4g ZmFsc2U7CisKKyAgICBjb25zdCBGcmFtZVNlbGVjdGlvbiogc2VsZWN0aW9uID0gZnJhbWUtPnNl bGVjdGlvbigpOworICAgIEVsZW1lbnQqIGVsZW1lbnQgPSBzZWxlY3Rpb24tPnJvb3RFZGl0YWJs ZUVsZW1lbnQoKTsKKyAgICBpZiAoIWVsZW1lbnQpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwor ICAgIHNpemVfdCBsb2NhdGlvbjsKKyAgICBzaXplX3QgbGVuZ3RoOworICAgIFJlZlB0cjxSYW5n ZT4gcmFuZ2UgPSBzZWxlY3Rpb24tPnNlbGVjdGlvbigpLmZpcnN0UmFuZ2UoKTsKKyAgICBpZiAo IXJhbmdlIHx8ICFUZXh0SXRlcmF0b3I6OmxvY2F0aW9uQW5kTGVuZ3RoRnJvbVJhbmdlKHJhbmdl LmdldCgpLCBsb2NhdGlvbiwgbGVuZ3RoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAg aWYgKHNlbGVjdGlvbi0+c2VsZWN0aW9uKCkuaXNCYXNlRmlyc3QoKSkgeworICAgICAgICBhbmNo b3IgPSBsb2NhdGlvbjsKKyAgICAgICAgZm9jdXMgPSBsb2NhdGlvbiArIGxlbmd0aDsKKyAgICB9 IGVsc2UgeworICAgICAgICBhbmNob3IgPSBsb2NhdGlvbjsKKyAgICAgICAgZm9jdXMgPSBsb2Nh dGlvbiArIGxlbmd0aDsKKyAgICB9CisKKyAgICB0ZXh0ID0gZWxlbWVudC0+aW5uZXJUZXh0KCk7 CisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogV2ViUmVjdCBXZWJWaWV3SW1wbDo6Y2FyZXRPclNl bGVjdGlvbkJvdW5kcygpCiB7CiAgICAgV2ViUmVjdCByZWN0OwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYlZpZXdJbXBsLmgKaW5kZXggMDFmYzkxMDVjMGRmNzZhNDZjNWUxYzBkMmI1NzMz M2VkZmEzMzM3ZC4uMWI3MWQ0YWZiYTU3YzU4MDhjMTBlZTdiOTQ4NWY5NzJlNWEzMTQzNyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAorKysgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBAIC0xMTcsNiArMTE3LDcg QEAgcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBjb25maXJtQ29tcG9zaXRpb24oY29uc3QgV2Vi U3RyaW5nJiB0ZXh0KTsKICAgICB2aXJ0dWFsIGJvb2wgY29tcG9zaXRpb25SYW5nZShzaXplX3Qq IGxvY2F0aW9uLCBzaXplX3QqIGxlbmd0aCk7CiAgICAgdmlydHVhbCBXZWJUZXh0SW5wdXRUeXBl IHRleHRJbnB1dFR5cGUoKTsKKyAgICB2aXJ0dWFsIGJvb2wgZ2V0U2VsZWN0aW9uT2Zmc2V0c0Fu ZFRleHRJbkVkaXRhYmxlQ29udGVudChXZWJTdHJpbmcmLCBzaXplX3QmIGZvY3VzLCBzaXplX3Qm IGFuY2hvcikgY29uc3Q7CiAgICAgdmlydHVhbCBXZWJSZWN0IGNhcmV0T3JTZWxlY3Rpb25Cb3Vu ZHMoKTsKICAgICB2aXJ0dWFsIGJvb2wgc2VsZWN0aW9uUmFuZ2UoV2ViUG9pbnQmIHN0YXJ0LCBX ZWJQb2ludCYgZW5kKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgY2FyZXRPclNlbGVjdGlvblJh bmdlKHNpemVfdCogbG9jYXRpb24sIHNpemVfdCogbGVuZ3RoKTsK