120297 2013-08-26 03:33:02 -0700 Need to check if some HTML child elements are HTMLUnknownElement 2013-10-05 08:00:33 -0700 1 1 1 Unclassified WebKit DOM 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P1 Normal --- 120584 1 gyuyoung.kim darin cdumez commit-queue darin esprehn+autocc ggaren gyuyoung.kim kangil.han kling rniwa xqhuang.webkit zan oldest_to_newest 920949 0 gyuyoung.kim 2013-08-26 03:33:02 -0700 As mentioned in https://bugs.webkit.org/show_bug.cgi?id=119951#c13, HTMLUnknownElement can own specific tag(e.g. audiotag, videoTag and so on) though it isn't correct element class. In this case, isHTMLXXXElement() returns "true" though it is HTMLUnknowElement. PassRefPtr<HTMLElement> HTMLElementFactory::createHTMLElement(const QualifiedName& qName, Document* document, HTMLFormElement* formElement, bool createdByParser) { if (!document) return 0; #if ENABLE(CUSTOM_ELEMENTS) if (document->registry()) { if (RefPtr<CustomElementConstructor> constructor = document->registry()->find(nullQName(), qName)) { RefPtr<Element> element = constructor->createElement(); ASSERT(element->isHTMLElement()); return static_pointer_cast<HTMLElement>(element.release()); } } #endif if (!gFunctionMap) createFunctionMap(); if (ConstructorFunction function = gFunctionMap->get(qName.localName().impl())) { if (PassRefPtr<HTMLElement> element = function(qName, document, formElement, createdByParser)) return element; } return HTMLUnknownElement::create(qName, document); 920953 1 gyuyoung.kim 2013-08-26 03:36:13 -0700 I wonder if we can add "unknownTag" for HTMLUnknownElement. Does anyone know if we can add it ? 920966 2 zan 2013-08-26 04:42:24 -0700 I was later thinking of simply checking that, for the problematic elements, the HTMLElement is not a HTMLUnknownElement: inline bool isHTMLAudioElement(Node* node) { return node->hasTagName(HTMLNames::audioTag) && !toHTMLElement(node)->isHTMLUnknownElement(); } 920975 3 gyuyoung.kim 2013-08-26 05:21:25 -0700 (In reply to comment #2) > I was later thinking of simply checking that, for the problematic elements, the HTMLElement is not a HTMLUnknownElement: > > inline bool isHTMLAudioElement(Node* node) > { > return node->hasTagName(HTMLNames::audioTag) && !toHTMLElement(node)->isHTMLUnknownElement(); > } Yes, I also think we can fix this issue by using it. However, it that case, we may need to add additional condition to many isHTMLXXXElement() functions. If we can't add unknownTag, it would be alternative solution. :) 920998 4 gyuyoung.kim 2013-08-26 06:33:58 -0700 (In reply to comment #3) > (In reply to comment #2) > > I was later thinking of simply checking that, for the problematic elements, the HTMLElement is not a HTMLUnknownElement: > > > > inline bool isHTMLAudioElement(Node* node) > > { > > return node->hasTagName(HTMLNames::audioTag) && !toHTMLElement(node)->isHTMLUnknownElement(); > > } > > Yes, I also think we can fix this issue by using it. However, it that case, we may need to add additional condition to many isHTMLXXXElement() functions. If we can't add unknownTag, it would be alternative solution. :) It looks we can't add "unknown" attribute because it should own a tag which is defined in a page. Even if we define new "unknown" attribute, we make a new attribute without spec definition. So, I think we can fix this issue using adding additional condition to isHTMLXXXElement() functions. 921007 5 zan 2013-08-26 06:50:04 -0700 The methods that need changing are not that many - only the ones that cast to an element of which the constructor in HTMLElementFactory can return 0. 921010 6 gyuyoung.kim 2013-08-26 07:04:06 -0700 (In reply to comment #5) > The methods that need changing are not that many - only the ones that cast to an element of which the constructor in HTMLElementFactory can return 0. Yes, right. Even three HTMLElement classes only have isHTMLXXXElement() functions. - HTMLSourceElement.h - HTMLTrackElement.h - HTMLContentElement.h I don't think we need to add isHTMLXXXElement() to other "return 0" classes which don't have the isHTMLXXXElement() in order to fix this problem at the moment. 921018 7 209654 gyuyoung.kim 2013-08-26 07:35:28 -0700 Created attachment 209654 Patch without test case 921019 8 gyuyoung.kim 2013-08-26 07:36:19 -0700 Let me try to add a test tomorrow. 921021 9 zan 2013-08-26 07:50:52 -0700 I've posted one test case (for the audio element) back in bug #119951. 921024 10 gyuyoung.kim 2013-08-26 08:04:10 -0700 (In reply to comment #9) > I've posted one test case (for the audio element) back in bug #119951. If you don't mind, can I use it ? I will add your name to ChangeLog as well. 921031 11 zan 2013-08-26 08:31:17 -0700 (In reply to comment #10) > (In reply to comment #9) > > I've posted one test case (for the audio element) back in bug #119951. > > If you don't mind, can I use it ? I will add your name to ChangeLog as well. Sure. Test cases for other elements (source, track) should work pretty much the same. I haven't looked into how the crash with HTMLContentElement could be produced. 921040 12 ggaren 2013-08-26 09:29:40 -0700 There are 1305 uses of hasTagName() in WebKit. Are all of them wrong, since they might accidentally be true for an HTMLUnknownElement? What patch introduced this behavior? 921041 13 ggaren 2013-08-26 09:31:45 -0700 Patching this in just one or two places is probably the wrong solution, since it doesn't address the fundamental problem that any line of code that tests for tag name might allow an HTMLUnknownElement through. 921044 14 209654 cdumez 2013-08-26 09:43:47 -0700 Comment on attachment 209654 Patch without test case View in context: https://bugs.webkit.org/attachment.cgi?id=209654&action=review > Source/WebCore/html/HTMLSourceElement.h:-67 > - return element->hasTagName(HTMLNames::sourceTag); We can only get an HTMLUnknownElement for sourceTag if VIDEO is disabled at compile time. Why not simply do: #if (VIDEO) return element->hasTagName(HTMLNames::sourceTag) #else UNUSED_PARAM(element); return false; #endif > Source/WebCore/html/HTMLTrackElement.h:102 > + return node->hasTagName(HTMLNames::trackTag) && !toHTMLElement(node)->isHTMLUnknownElement(); Ditto with VIDEO_TRACK flag > Source/WebCore/html/HTMLTrackElement.h:107 > + return element->hasTagName(HTMLNames::trackTag) && !toHTMLElement(element)->isHTMLUnknownElement(); Ditto 921050 15 209654 cdumez 2013-08-26 09:58:41 -0700 Comment on attachment 209654 Patch without test case View in context: https://bugs.webkit.org/attachment.cgi?id=209654&action=review >> Source/WebCore/html/HTMLSourceElement.h:-67 >> - return element->hasTagName(HTMLNames::sourceTag); > > We can only get an HTMLUnknownElement for sourceTag if VIDEO is disabled at compile time. Why not simply do: > #if (VIDEO) > return element->hasTagName(HTMLNames::sourceTag) > #else > UNUSED_PARAM(element); > return false; > #endif BTW, this looks like a good reason to generate those isXXXElement functions. It is bug prone otherwise. 921289 16 gyuyoung.kim 2013-08-26 18:57:17 -0700 (In reply to comment #13) > Patching this in just one or two places is probably the wrong solution, since it doesn't address the fundamental problem that any line of code that tests for tag name might allow an HTMLUnknownElement through. I wanted to solve this issue by fixing root cause. So, I thought that HTMLUnknownElement() needs to have own tag name in order to do fix it. However, it looks it is spec violation. In this case, problem is that HTMLUnknownElement can have valid element. (It only can have audioTag, sourceTag, trackTag, videoTag, contentElement and dialogTag.) Then, how about setting qName as null as below ?, or do you think we can define new tag for this case ? if (ConstructorFunction function = gFunctionMap->get(qName.localName().impl())) { if (PassRefPtr<HTMLElement> element = function(qName, document, formElement, createdByParser)) return element; else qName = 0 or new tag; } return HTMLUnknownElement::create(qName, document); 921292 17 209654 gyuyoung.kim 2013-08-26 19:05:04 -0700 Comment on attachment 209654 Patch without test case View in context: https://bugs.webkit.org/attachment.cgi?id=209654&action=review >>> Source/WebCore/html/HTMLSourceElement.h:-67 >>> - return element->hasTagName(HTMLNames::sourceTag); >> >> We can only get an HTMLUnknownElement for sourceTag if VIDEO is disabled at compile time. Why not simply do: >> #if (VIDEO) >> return element->hasTagName(HTMLNames::sourceTag) >> #else >> UNUSED_PARAM(element); >> return false; >> #endif > > BTW, this looks like a good reason to generate those isXXXElement functions. It is bug prone otherwise. We need to consider HTMLElementFactory return 0 with a tag. However, it looks some ctor functions can return 0 when the macro is enabled at compile time. So, It don't think we can avoid this problem when using ENABLE() macro. In WebKitBuild/Release/DerivedSources/WebCore/HTMLElementFactory.cpp #if ENABLE(SHADOW_DOM) static PassRefPtr<HTMLElement> contentConstructor(const QualifiedName& tagName, Document* document, HTMLFormElement*, bool) { if (!RuntimeEnabledFeatures::shadowDOMEnabled()) return 0; return HTMLContentElement::create(tagName, document); } #endif #if ENABLE(DIALOG_ELEMENT) static PassRefPtr<HTMLElement> dialogConstructor(const QualifiedName& tagName, Document* document, HTMLFormElement*, bool) { if (!ContextFeatures::dialogElementEnabled(document)) return 0; return HTMLDialogElement::create(tagName, document); } #endif #if ENABLE(VIDEO) static PassRefPtr<HTMLElement> sourceConstructor(const QualifiedName& tagName, Document* document, HTMLFormElement*, bool) { Settings* settings = document->settings(); if (!MediaPlayer::isAvailable() || (settings && !settings->mediaEnabled())) return 0; return HTMLSourceElement::create(tagName, document); } #endif ... 921332 18 gyuyoung.kim 2013-08-26 21:26:21 -0700 (In reply to comment #16) > Then, how about setting qName as null as below ?, or do you think we can define new tag for this case ? > > if (ConstructorFunction function = gFunctionMap->get(qName.localName().impl())) { > if (PassRefPtr<HTMLElement> element = function(qName, document, formElement, createdByParser)) > return element; > else > qName = 0 or new tag; > } > > return HTMLUnknownElement::create(qName, document); qName can't be changed because it is const. So, we may try to return HTMLUnknownElement with a null QualifiedName() as below, else return HTMLUnknownElement::create(QualifiedName(nullAtom, nullAtom, nullAtom), document); return HTMLUnknownElement::create(qName, document); 921342 19 cdumez 2013-08-26 23:53:27 -0700 (In reply to comment #17) > (From update of attachment 209654 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=209654&action=review > > >>> Source/WebCore/html/HTMLSourceElement.h:-67 > >>> - return element->hasTagName(HTMLNames::sourceTag); > >> > >> We can only get an HTMLUnknownElement for sourceTag if VIDEO is disabled at compile time. Why not simply do: > >> #if (VIDEO) > >> return element->hasTagName(HTMLNames::sourceTag) > >> #else > >> UNUSED_PARAM(element); > >> return false; > >> #endif > > > > BTW, this looks like a good reason to generate those isXXXElement functions. It is bug prone otherwise. > > We need to consider HTMLElementFactory return 0 with a tag. However, it looks some ctor functions can return 0 when the macro is enabled at compile time. So, It don't think we can avoid this problem when using ENABLE() macro. > > In WebKitBuild/Release/DerivedSources/WebCore/HTMLElementFactory.cpp > > #if ENABLE(SHADOW_DOM) > > static PassRefPtr<HTMLElement> contentConstructor(const QualifiedName& tagName, Document* document, HTMLFormElement*, bool) > { > if (!RuntimeEnabledFeatures::shadowDOMEnabled()) > return 0; > return HTMLContentElement::create(tagName, document); > } > > #endif > > #if ENABLE(DIALOG_ELEMENT) > > static PassRefPtr<HTMLElement> dialogConstructor(const QualifiedName& tagName, Document* document, HTMLFormElement*, bool) > { > if (!ContextFeatures::dialogElementEnabled(document)) > return 0; > return HTMLDialogElement::create(tagName, document); > } > > #endif > > #if ENABLE(VIDEO) > > static PassRefPtr<HTMLElement> sourceConstructor(const QualifiedName& tagName, Document* document, HTMLFormElement*, bool) > { > Settings* settings = document->settings(); > if (!MediaPlayer::isAvailable() || (settings && !settings->mediaEnabled())) > return 0; > > return HTMLSourceElement::create(tagName, document); > } > > #endif > > ... Right, is some cases the feature is enabled at runtime, not simply compile time. However, since this factory is generated, this means we already have all the information we need to generate the isHTML*Element() functions, rignt? 921343 20 gyuyoung.kim 2013-08-27 00:02:24 -0700 (In reply to comment #19) > > Right, is some cases the feature is enabled at runtime, not simply compile time. However, since this factory is generated, this means we already have all the information we need to generate the isHTML*Element() functions, rignt? I'm not sure if we should generate isHTML*Element() for all tags at the moment. However, I think we need to support isHTML*Element() for 'return 0' ctor at least. 921344 21 cdumez 2013-08-27 00:13:24 -0700 (In reply to comment #20) > (In reply to comment #19) > > > > Right, is some cases the feature is enabled at runtime, not simply compile time. However, since this factory is generated, this means we already have all the information we need to generate the isHTML*Element() functions, rignt? > > I'm not sure if we should generate isHTML*Element() for all tags at the moment. However, I think we need to support isHTML*Element() for 'return 0' ctor at least. Can you explain why you don't want to generate them? From what I can see, the isHTML*Element() functions code needs to match what is in an already generated file (the HTMLElementFactory). Since we are able to generate the HTMLElementFactory already, it should be trivial to generate the isHTML*Element() functions. However, doing this work manually seems risky, bug prone and difficult to maintain. 921345 22 gyuyoung.kim 2013-08-27 00:20:52 -0700 (In reply to comment #21) > (In reply to comment #20) > > (In reply to comment #19) > > > > > > Right, is some cases the feature is enabled at runtime, not simply compile time. However, since this factory is generated, this means we already have all the information we need to generate the isHTML*Element() functions, rignt? > > > > I'm not sure if we should generate isHTML*Element() for all tags at the moment. However, I think we need to support isHTML*Element() for 'return 0' ctor at least. > > Can you explain why you don't want to generate them? There was concerns when we contributed isFooElement() to blink. One is some C++ Element subclasses represent multiple tag names. e.g. HTMLQuoteElement represents <blockquote> and <q>, however, hasTagName(blockquoteTag) and hasTagName(qTag) are not always checked together. We can't replace all of hasTagName(blockquoteTag) with isHTMLQuoteElement() Other is to add "#include "FooElement.h" cause unnecessary dependency. HTML parser should avoid to depend on C++ element implementation class if possible. 921348 23 cdumez 2013-08-27 00:38:57 -0700 (In reply to comment #22) > (In reply to comment #21) > > (In reply to comment #20) > > > (In reply to comment #19) > > > > > > > > Right, is some cases the feature is enabled at runtime, not simply compile time. However, since this factory is generated, this means we already have all the information we need to generate the isHTML*Element() functions, rignt? > > > > > > I'm not sure if we should generate isHTML*Element() for all tags at the moment. However, I think we need to support isHTML*Element() for 'return 0' ctor at least. > > > > Can you explain why you don't want to generate them? > > There was concerns when we contributed isFooElement() to blink. > > One is some C++ Element subclasses represent multiple tag names. e.g. HTMLQuoteElement represents <blockquote> and <q>, however, hasTagName(blockquoteTag) and hasTagName(qTag) are not always checked together. We can't replace all of hasTagName(blockquoteTag) with isHTMLQuoteElement() This seems like an argument not to use the isHTML*Element() in some cases, not an argument against generating the isHTML*Element() functions. I mean, does this statement ever affect the code you write for isHTML*Element()? > Other is to add "#include "FooElement.h" cause unnecessary dependency. HTML parser should avoid to depend on C++ element implementation class if possible. Actually, if you generate those isHTML*element() functions, they will likely all be in the same file. e.g. HTMLElementHelpers.h or something like that. And as far as I can see, this file would not need to include any FooElement.h, only HTMLNames.h and likely RuntimeEnabledFeatures.h. And again, if we don't want to add include in one place, well, we don't have to use the generated isHTML*Element() functions. The fact that they are generated and available does not mandate that you need to use them everywhere. I am adding a few people in CC as I am curious what WebKit people think about generating these. 921361 24 zan 2013-08-27 01:01:58 -0700 I'm all for generating the is*Element() and to*Element() functions. Since there are elements for which these helpers are not required, perhaps we could specifically annotate the elements in HTMLTagNames.in that should have them generated. I guess similar could be done for the SVG elements, in svgtags.in. 921365 25 gyuyoung.kim 2013-08-27 01:13:44 -0700 (In reply to comment #24) > I'm all for generating the is*Element() and to*Element() functions. Since there are elements for which these helpers are not required, perhaps we could specifically annotate the elements in HTMLTagNames.in that should have them generated. If we can specify which element needs to have isFooElement() or toFooElement(), we may generate the needed isFooElement() and toFooElement(). > I guess similar could be done for the SVG elements, in svgtags.in. If we can adjust the generation into HTML elements, IMHO, we can do it on SVG as well. 921377 26 209726 gyuyoung.kim 2013-08-27 01:48:40 -0700 Created attachment 209726 WIP suggestion according to comment #18 921382 27 gyuyoung.kim 2013-08-27 01:50:39 -0700 (In reply to comment #26) > Created an attachment (id=209726) [details] > WIP suggestion according to comment #18 I would like to know how do you think to use this suggestion instead of modifying isHTML*Element(). 921398 28 209726 cdumez 2013-08-27 02:19:42 -0700 Comment on attachment 209726 WIP suggestion according to comment #18 View in context: https://bugs.webkit.org/attachment.cgi?id=209726&action=review > Source/WebCore/dom/make_names.pl:955 > + return $parameters{fallbackInterfaceName}::create(QualifiedName(nullAtom, nullAtom, nullAtom), document); what does the factory code look like with this change? It is not obvious for me. 921450 29 gyuyoung.kim 2013-08-27 05:08:48 -0700 (In reply to comment #28) > (From update of attachment 209726 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=209726&action=review > > > Source/WebCore/dom/make_names.pl:955 > > + return $parameters{fallbackInterfaceName}::create(QualifiedName(nullAtom, nullAtom, nullAtom), document); > > what does the factory code look like with this change? It is not obvious for me. In HTMLElementFactory::createHTMLElement(), the factory function creates new element. However, as I said many times, some creation functions can return 0. In that case, element is null. then the factory function returns a HTMLUnknownElement instance with valid tags(e.g. audioTag, videoTag, trackTag and so on) if (ConstructorFunction function = gFunctionMap->get(qName.localName().impl())) { if (PassRefPtr<HTMLElement> element = function(qName, document, formElement, createdByParser)) return element; } return HTMLUnknownElement::create(qName, document); // audioConstructor static PassRefPtr<HTMLElement> audioConstructor(const QualifiedName& tagName, Document* document, HTMLFormElement*, bool createdByParser) { Settings* settings = document->settings(); if (!MediaPlayer::isAvailable() || (settings && !settings->mediaEnabled())) return 0; // audioConstructor may return 0. My second suggestion is that we return HTMLUnknownElement with null tag name because this isn't an unknown situation. This case is that element creation is failed. So, my suggestion is to consider to return HTMLUnknownElement() with null tag. As far as I understand, HTMLUnknownElement supports tags out of specification, for example, <foo1></foo1>, <stupid></stupid> and so on. But, this case is not the situation for it. 923644 30 zan 2013-09-02 03:11:25 -0700 Bug #120584 is working on generating the is*Element() checks. I think we should work on top of that. 923647 31 gyuyoung.kim 2013-09-02 03:29:59 -0700 (In reply to comment #30) > Bug #120584 is working on generating the is*Element() checks. I think we should work on top of that. ok, let's work on this after landing it. BTW, current test case doesn't make a crash on EFL port. I'm taking a look it. 932089 32 xqhuang.webkit 2013-09-23 02:43:39 -0700 (In reply to comment #31) > (In reply to comment #30) > > Bug #120584 is working on generating the is*Element() checks. I think we should work on top of that. > > ok, let's work on this after landing it. BTW, current test case doesn't make a crash on EFL port. I'm taking a look it. Windows port could reproduce the crash caused by this issue. HTMLUnknownElement override |isHTMLUnknownElement| and return true, I suggest check whether an element was a HTMLUnknownElement or not via isHTMLUnknownElement in |isHTML*Element()|. e.g: bool isHTMLAudioElement(const Element& element) { return element.hasTagName(HTMLNames::audioTag) && !isHTMLUnknownElement(element); } 932091 33 xqhuang.webkit 2013-09-23 02:45:04 -0700 *** Bug 121537 has been marked as a duplicate of this bug. *** 932164 34 darin 2013-09-23 09:32:59 -0700 (In reply to comment #2) > I was later thinking of simply checking that, for the problematic elements, the HTMLElement is not a HTMLUnknownElement: > > inline bool isHTMLAudioElement(Node* node) > { > return node->hasTagName(HTMLNames::audioTag) && !toHTMLElement(node)->isHTMLUnknownElement(); > } Yes, I think this is exactly what we want to do, only for the elements that can be affected by this. 932166 35 darin 2013-09-23 09:34:11 -0700 (In reply to comment #29) > However, as I said many times, some creation functions can return 0. In that case, element is null. Exactly. We will need code to check for unknown elements in the isXXX function for any of the creation functions that can return nullptr. And we should minimize our use of this technique. It’s not really a good pattern. 935790 36 gyuyoung.kim 2013-10-03 08:49:27 -0700 Hmm, crash doesn't occurs on existing test. It looks this crash was fixed indirectly. I will check if this crash is really fixed. Can anyone reproduce this crash now ? 935918 37 darin 2013-10-03 12:35:06 -0700 I don’t see evidence that the isHTMLAudioElement function has been fixed. The script that generates constructors and isHTMLAudioElement functions still seems to be checking MediaPlayer::isAvailable and settings && !settings->mediaEnabled() in the audio element constructor and in the audio element createWrapper function, but not in the isHTMLAudioElement function. From what I see from code inspection, this still needs to be fixed. 935960 38 zan 2013-10-03 13:57:19 -0700 I can still reproduce this crash on the GTK port with running the test case I've attached in bug #119951 through either DumpRenderTree or WebKitTestRunner. Things basically go FUBAR when WebCore::JSNodeOwner::isReachableFromOpaqueRoots is reached during the GC and the isHTMLAudioElement() check returns a false positive in the isReachableFromDOM function. 936169 39 213353 gyuyoung.kim 2013-10-04 06:03:42 -0700 Created attachment 213353 WIP 936171 40 gyuyoung.kim 2013-10-04 06:08:47 -0700 First of all, sorry for too late update. BTW, I'm suspecting if we need to return a fallback element when MediaPlayer isn't available. Besides there was a similar patch for V8 binding. https://bugs.webkit.org/show_bug.cgi?id=103431 Unfortunately, I have a reproduce problem because of my env problem. I will re-submit a new patch after fixing my env problem. 936531 41 darin 2013-10-05 00:02:32 -0700 I’ll fix this. 936533 42 213445 darin 2013-10-05 00:22:30 -0700 Created attachment 213445 Patch 936534 43 commit-queue 2013-10-05 00:24:59 -0700 Attachment 213445 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/ChangeLog', u'Source/WebCore/dom/make_names.pl', u'Source/WebCore/html/HTMLElement.h']" exit_code: 1 Source/WebCore/html/HTMLElement.h:147: Alphabetical sorting problem. [build/include_order] [4] Total errors found: 1 in 3 files If any of these errors are false positives, please file a bug against check-webkit-style. 936542 44 213445 kling 2013-10-05 00:53:17 -0700 Comment on attachment 213445 Patch r=me The previous patch on this bug had a layout test. We should make sure to add it as well, assuming it works. 936558 45 gyuyoung.kim 2013-10-05 06:48:58 -0700 Darin, please land after fixing style error. 936559 46 darin 2013-10-05 06:52:13 -0700 (In reply to comment #45) > Darin, please land after fixing style error. That’s not a style error. That’s the style script incorrectly complaining about an include that is not not part of the normal includes at the top of the file. 936560 47 darin 2013-10-05 06:52:53 -0700 (In reply to comment #44) > The previous patch on this bug had a layout test. We should make sure to add it as well, assuming it works. I’ll add the layout test and check that it demonstrates the bug before I land. 936569 48 darin 2013-10-05 08:00:33 -0700 Committed r156953: <http://trac.webkit.org/changeset/156953> 209654 2013-08-26 07:35:28 -0700 2013-08-27 01:48:31 -0700 Patch without test case bug-120297-20130826233527.patch text/plain 3646 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTU0NTk5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWJlM2JhZWJjMzA3Yjcx NWJmMjNmOTRhYWQ1ZDAzN2FkY2M1MzNlZC4uYWI4N2U0NmNlZTdiM2VhNDA2NmQ5NDdjM2Q2ZTlh NzZjYThjZTIwYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEzLTA4LTI2ICBHeXV5 b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+CisKKyAgICAgICAgTmVlZCB0byBj aGVjayBpZiBzb21lIEhUTUwgY2hpbGQgZWxlbWVudHMgYXJlIEhUTUxVbmtub3duRWxlbWVudAor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTIwMjk3CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSFRNTEVsZW1l bnRGYWN0b3J5OjpjcmVhdGVIVE1MRWxlbWVudCgpIGNhbiByZXR1cm4gSFRNTFVua25vd25FbGVt ZW50IHdpdGggYSB2YWxpZCB0YWcuCisgICAgICAgIEZvciBleGFtcGxlLCBhdWRpb1RhZywgc291 cmNlVGFnLCB0cmFja1RhZyBhbmQgc28gb24uIEluIHRoYXQgY2FzZSwgY3Jhc2ggb2NjdXJzIHdo ZW4gY2FzdGluZworICAgICAgICBmcm9tIEhUTUxVbmtub3duRWxlbWVudCB0byB2YWxpZCBIVE1M IGNoaWxkIEVsZW1lbnQuIFRodXMsIGlzSFRNTFhYWEVsZW1lbnQoKSBuZWVkIHRvIGFkZCBhbgor ICAgICAgICBhZGRpdGlvbmFsIGNvbmRpdGlvbiB0byBjaGVjayB3aGV0aGVyIEhUTUxFbGVtZW50 IGlzIEhUTUxVbmtub3duRWxlbWVudC4KKworICAgICAgICAqIGh0bWwvSFRNTFNvdXJjZUVsZW1l bnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OmlzSFRNTFNvdXJjZUVsZW1lbnQpOgorICAgICAgICAq IGh0bWwvSFRNTFRyYWNrRWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6aXNIVE1MVHJhY2tF bGVtZW50KToKKyAgICAgICAgKiBodG1sL3NoYWRvdy9IVE1MQ29udGVudEVsZW1lbnQuaDoKKyAg ICAgICAgKFdlYkNvcmU6OmlzSFRNTENvbnRlbnRFbGVtZW50KToKKwogMjAxMy0wOC0yNiAgQW5k cmVhcyBLbGluZyAgPGFrbGluZ0BhcHBsZS5jb20+CiAKICAgICAgICAgTW92ZSBEb2N1bWVudFRp bWluZyBpbnNpZGUgRU5BQkxFKFdFQl9USU1JTkcpIGd1YXJkcy4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTFNvdXJjZUVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTFNvdXJjZUVsZW1lbnQuaAppbmRleCBmYzkyMmJjYzM5MjU1MDE2YzBjMDU0OTAwY2FjNmMw ZTdhYzJlMDQwLi5mMWVjNGFlNzc3MjExNzhjYmE1NzMwODcxMjhkZmFmZDNkNzE2NWY5IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxTb3VyY2VFbGVtZW50LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MU291cmNlRWxlbWVudC5oCkBAIC02NCw3ICs2NCw3IEBAIGlu bGluZSBib29sIGlzSFRNTFNvdXJjZUVsZW1lbnQoY29uc3QgTm9kZSogbm9kZSkKIAogaW5saW5l IGJvb2wgaXNIVE1MU291cmNlRWxlbWVudChjb25zdCBFbGVtZW50KiBlbGVtZW50KQogewotICAg IHJldHVybiBlbGVtZW50LT5oYXNUYWdOYW1lKEhUTUxOYW1lczo6c291cmNlVGFnKTsKKyAgICBy ZXR1cm4gZWxlbWVudC0+aGFzVGFnTmFtZShIVE1MTmFtZXM6OnNvdXJjZVRhZykgJiYgIXRvSFRN TEVsZW1lbnQoZWxlbWVudCktPmlzSFRNTFVua25vd25FbGVtZW50KCk7CiB9CiAKIHRlbXBsYXRl IDw+IGlubGluZSBib29sIGlzRWxlbWVudE9mVHlwZTxIVE1MU291cmNlRWxlbWVudD4oY29uc3Qg RWxlbWVudCogZWxlbWVudCkgeyByZXR1cm4gaXNIVE1MU291cmNlRWxlbWVudChlbGVtZW50KTsg fQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVHJhY2tFbGVtZW50LmggYi9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxUcmFja0VsZW1lbnQuaAppbmRleCBjNzkzYjM0YzVkYmZm MzYyMGQ0ZTRkNzdhMzJmYjdlZTIzMDE0YjgxLi4wYzZjNzQ4MTY4ZTI3OWE0NTUxZGEyMGViY2I5 ZjJiNWQzYzUyMTQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxUcmFja0Vs ZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxUcmFja0VsZW1lbnQuaApAQCAt OTksMTIgKzk5LDEyIEBAIHByaXZhdGU6CiAKIGlubGluZSBib29sIGlzSFRNTFRyYWNrRWxlbWVu dChjb25zdCBOb2RlKiBub2RlKQogewotICAgIHJldHVybiBub2RlLT5oYXNUYWdOYW1lKEhUTUxO YW1lczo6dHJhY2tUYWcpOworICAgIHJldHVybiBub2RlLT5oYXNUYWdOYW1lKEhUTUxOYW1lczo6 dHJhY2tUYWcpICYmICF0b0hUTUxFbGVtZW50KG5vZGUpLT5pc0hUTUxVbmtub3duRWxlbWVudCgp OwogfQogCiBpbmxpbmUgYm9vbCBpc0hUTUxUcmFja0VsZW1lbnQoY29uc3QgRWxlbWVudCogZWxl bWVudCkKIHsKLSAgICByZXR1cm4gZWxlbWVudC0+aGFzVGFnTmFtZShIVE1MTmFtZXM6OnRyYWNr VGFnKTsKKyAgICByZXR1cm4gZWxlbWVudC0+aGFzVGFnTmFtZShIVE1MTmFtZXM6OnRyYWNrVGFn KSAmJiAhdG9IVE1MRWxlbWVudChlbGVtZW50KS0+aXNIVE1MVW5rbm93bkVsZW1lbnQoKTsKIH0K IAogdGVtcGxhdGUgPD4gaW5saW5lIGJvb2wgaXNFbGVtZW50T2ZUeXBlPEhUTUxUcmFja0VsZW1l bnQ+KGNvbnN0IEVsZW1lbnQqIGVsZW1lbnQpIHsgcmV0dXJuIGlzSFRNTFRyYWNrRWxlbWVudChl bGVtZW50KTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvSFRNTENv bnRlbnRFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9IVE1MQ29udGVudEVs ZW1lbnQuaAppbmRleCA1MzgwODg4MzI2Y2E3MjkwYjQwNjEzOTJjYWI4ODA1NzExNWMxYmJiLi4z M2RkZTJmODVjMGE1NTNjMzRkYzk4YmFjYmUyYzI5ZTMyYzc5YmNiIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9odG1sL3NoYWRvdy9IVE1MQ29udGVudEVsZW1lbnQuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL3NoYWRvdy9IVE1MQ29udGVudEVsZW1lbnQuaApAQCAtODMsNyArODMsNyBA QCBpbmxpbmUgY29uc3QgQ1NTU2VsZWN0b3JMaXN0JiBIVE1MQ29udGVudEVsZW1lbnQ6OnNlbGVj dG9yTGlzdCgpCiBpbmxpbmUgYm9vbCBpc0hUTUxDb250ZW50RWxlbWVudChjb25zdCBOb2RlKiBu b2RlKQogewogICAgIEFTU0VSVChub2RlKTsKLSAgICByZXR1cm4gbm9kZS0+aXNJbnNlcnRpb25Q b2ludCgpICYmIHRvSW5zZXJ0aW9uUG9pbnQobm9kZSktPmluc2VydGlvblBvaW50VHlwZSgpID09 IEluc2VydGlvblBvaW50OjpIVE1MQ29udGVudEVsZW1lbnRUeXBlOworICAgIHJldHVybiBub2Rl LT5pc0luc2VydGlvblBvaW50KCkgJiYgdG9JbnNlcnRpb25Qb2ludChub2RlKS0+aW5zZXJ0aW9u UG9pbnRUeXBlKCkgPT0gSW5zZXJ0aW9uUG9pbnQ6OkhUTUxDb250ZW50RWxlbWVudFR5cGUgJiYg IXRvSFRNTEVsZW1lbnQobm9kZSktPmlzSFRNTFVua25vd25FbGVtZW50KCk7CiB9CiAKIGlubGlu ZSBIVE1MQ29udGVudEVsZW1lbnQqIHRvSFRNTENvbnRlbnRFbGVtZW50KE5vZGUqIG5vZGUpCg== 209726 2013-08-27 01:48:40 -0700 2013-10-04 06:03:30 -0700 WIP suggestion according to comment #18 bug-120297-20130827174839.patch text/plain 3991 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTU0NjY0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTUzYmQxZDZhZDAwNjdl NmQxMjhkOWI1ZTZhZmEwNjg4ZDI5OWE5MC4uOGRlNTAxOTQ4OTU1ODVmZjI4ZTRlYzc1NjQ0ZmZk MzcwMTFhNzBkNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEzLTA4LTI3ICBHeXV5 b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+CisKKyAgICAgICAgTmVlZCB0byBj aGVjayBpZiBzb21lIEhUTUwgY2hpbGQgZWxlbWVudHMgYXJlIEhUTUxVbmtub3duRWxlbWVudAor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTIwMjk3CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSFRNTEVsZW1l bnRGYWN0b3J5OjpjcmVhdGVIVE1MRWxlbWVudCgpIGNhbiByZXR1cm4gSFRNTFVua25vd25FbGVt ZW50IHdpdGggYSB2YWxpZCB0YWcuCisgICAgICAgIEZvciBleGFtcGxlLCBhdWRpb1RhZywgc291 cmNlVGFnLCB0cmFja1RhZyBhbmQgc28gb24uIEluIHRoYXQgY2FzZSwgY3Jhc2ggb2NjdXJzIHdo ZW4gY2FzdGluZworICAgICAgICBmcm9tIEhUTUxVbmtub3duRWxlbWVudCB0byB2YWxpZCBIVE1M IGNoaWxkIEVsZW1lbnQuCisKKyAgICAgICAgVGVzdDogZmFzdC9odG1sL3Vua25vd24tdGFnLWNy YXNoLmh0bWwKKworICAgICAgICAqIGRvbS9tYWtlX25hbWVzLnBsOgorCiAyMDEzLTA4LTI2ICBT YW0gV2VpbmlnICA8c2FtQHdlYmtpdC5vcmc+CiAKICAgICAgICAgRWRpdG9ySW50ZXJuYWxDb21t YW5kIHNob3VsZCB1c2UgRnJhbWUmIHdoZXJlIHBvc3NpYmxlCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9kb20vbWFrZV9uYW1lcy5wbCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9tYWtlX25hbWVz LnBsCmluZGV4IGM4NjY3NjFmZThiMjNjZGIzMzQyYjhlOGNmNjVkZTU3YzllZjFlYTQuLmNhZWU3 Mzc1YWNlMzI1ZmUzMjc4N2JiOTQ0OTNkMjAxMzNlMjkyNzAgMTAwNzU1Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2RvbS9tYWtlX25hbWVzLnBsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9tYWtlX25h bWVzLnBsCkBAIC05NTEsNiArOTUxLDggQEAgaWYgKCRwYXJhbWV0ZXJze25hbWVzcGFjZX0gZXEg IkhUTUwiKSB7CiAgICAgcHJpbnQgRiAiICAgICAgICAgICAgcmV0dXJuIGVsZW1lbnQ7XG4iOwog fQogcHJpbnQgRiA8PEVORAorICAgICAgICBlbHNlCisgICAgICAgICAgICByZXR1cm4gJHBhcmFt ZXRlcnN7ZmFsbGJhY2tJbnRlcmZhY2VOYW1lfTo6Y3JlYXRlKFF1YWxpZmllZE5hbWUobnVsbEF0 b20sIG51bGxBdG9tLCBudWxsQXRvbSksIGRvY3VtZW50KTsKICAgICB9CiAKICAgICByZXR1cm4g JHBhcmFtZXRlcnN7ZmFsbGJhY2tJbnRlcmZhY2VOYW1lfTo6Y3JlYXRlKHFOYW1lLCBkb2N1bWVu dCk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKaW5kZXggNzUzMzQzZTZhNmU2OTg3MmEyZWQyMzc1ZTQzMTkwZTA0OTM3NWMyNi4uYTRh ODE0ZGZmNjZiMThkYTJlN2U1NDYxZjBmYmU1MTdjNmE0Nzg0NyAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEz IEBACisyMDEzLTA4LTI3ICBHeXV5b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+ CisKKyAgICAgICAgTmVlZCB0byBjaGVjayBpZiBzb21lIEhUTUwgY2hpbGQgZWxlbWVudHMgYXJl IEhUTUxVbmtub3duRWxlbWVudAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTIwMjk3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgKiBmYXN0L2h0bWwvdW5rbm93bi10YWctY3Jhc2gtZXhwZWN0ZWQudHh0OiBB ZGRlZC4KKyAgICAgICAgKiBmYXN0L2h0bWwvdW5rbm93bi10YWctY3Jhc2guaHRtbDogQWRkZWQu CisKIDIwMTMtMDgtMjYgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAgICAg ICAgRWxlbWVudHMgaW4gYSBub2RlIGxpc3Qgb2YgdGhlIGZvcm0gZWxlbWVudCdzIG5hbWUgZ2V0 dGVyIHNob3VsZCBub3QgYmUgYWRkZWQgdG8gdGhlIHBhc3QgbmFtZXMgbWFwCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2h0bWwvdW5rbm93bi10YWctY3Jhc2gtZXhwZWN0ZWQudHh0IGIv TGF5b3V0VGVzdHMvZmFzdC9odG1sL3Vua25vd24tdGFnLWNyYXNoLWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi40NDRjMzYyYjg0YzgyMWRmYTM5MjMyZGI2YzJjNjJmNzY5ODZjZDU3Ci0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9odG1sL3Vua25vd24tdGFnLWNyYXNoLWV4cGVj dGVkLnR4dApAQCAtMCwwICsxIEBACitUaGUgdGVzdCBwYXNzZXMgaWYgaXQgZG9lc24ndCBjcmFz aC4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvaHRtbC91bmtub3duLXRhZy1jcmFzaC5o dG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9odG1sL3Vua25vd24tdGFnLWNyYXNoLmh0bWwKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uMDNmNmFhN2M2ODJlNWE2ZjY0MWRmODU3NWM1NGE5ZTk1MjY5MDk4OAotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvaHRtbC91bmtub3duLXRhZy1jcmFzaC5odG1sCkBA IC0wLDAgKzEsNDkgQEAKKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0PgorCitmdW5jdGlvbiBtZWRp YVRlc3QoKSB7CisgICAgaWYgKHdpbmRvdy5pbnRlcm5hbHMpCisgICAgICAgIHdpbmRvdy5pbnRl cm5hbHMuc2V0dGluZ3Muc2V0TWVkaWFFbmFibGVkKGZhbHNlKTsKKworICAgIHZhciBhdWRpb0Vs ZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJhdWRpbyIpOworICAgIGF1ZGlvRWxlbWVu dCA9IG51bGw7CisKKyAgICB2YXIgdmlkZW9FbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVu dCgidmlkZW8iKTsKKyAgICB2aWRlb0VsZW1lbnQgPSBudWxsOworCisgICAgdmFyIHZpZGVvVHJh Y2tFbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgidHJhY2siKTsKKyAgICB2aWRlb1Ry YWNrRWxlbWVudCA9IG51bGw7CisKKyAgICB2YXIgc291cmNlRWxlbWVudCA9IGRvY3VtZW50LmNy ZWF0ZUVsZW1lbnQoInNvdXJjZSIpOworICAgIHNvdXJjZUVsZW1lbnQgPSBudWxsOworCisgICAg aWYgKHdpbmRvdy5HQ0NvbnRyb2xsZXIpCisgICAgICAgIEdDQ29udHJvbGxlci5jb2xsZWN0KCk7 Cit9CisKK2Z1bmN0aW9uIGRpYWxvZ1Rlc3QoKSB7CisgICAgaWYgKHdpbmRvdy5pbnRlcm5hbHMp CisgICAgICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0RGlhbG9nRWxlbWVudEVuYWJs ZWQoZmFsc2UpOworCisgICAgdmFyIGRpYWxvZ0VsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVt ZW50KCJkaWFsb2ciKTsKKyAgICBkaWFsb2dFbGVtZW50ID0gbnVsbDsKKworICAgIGlmICh3aW5k b3cuR0NDb250cm9sbGVyKQorICAgICAgICBHQ0NvbnRyb2xsZXIuY29sbGVjdCgpOworfQorCitm dW5jdGlvbiBydW5UZXN0KCkgeworICAgIGlmICh3aW5kb3cudGVzdFJ1bm5lcikKKyAgICAgICAg dGVzdFJ1bm5lci5kdW1wQXNUZXh0KCk7CisKKyAgICBtZWRpYVRlc3QoKTsKKyAgICBkaWFsb2dU ZXN0KCk7Cit9Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0icnVuVGVzdCgpIj4K K1RoZSB0ZXN0IHBhc3NlcyBpZiBpdCBkb2Vzbid0IGNyYXNoLgorPC9ib2R5PgorPC9odG1sPgor Cg== 213353 2013-10-04 06:03:42 -0700 2013-10-05 00:22:24 -0700 WIP bug-120297-20131004220341.patch text/plain 3998 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTU2ODgwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWNmZGY4NzViMGZlNjQ3 ZjI5YzUyZGFmNTcwODA2YjkyZmE0N2U5YS4uZTAxZDFhNzA0ZDZkOTQ2M2E4NWUzN2RlZDA1YTk2 YTM1ODc1MDM4ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEzLTEwLTA0ICBHeXV5 b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+CisKKyAgICAgICAgUmV0dXJuIGEg ZmFsbGJhY2sgZWxlbWVudCB3aGVuIE1lZGlhUGxheWVyIGlzbid0IGF2YWlsYWJsZQorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTIwMjk3CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSFRNTEVsZW1lbnRGYWN0 b3J5OjpjcmVhdGVFbGVtZW50KCkgY2FuIHJldHVybiBIVE1MVW5rbm93bkVsZW1lbnQgd2l0aCBh IHZhbGlkIHRhZy4KKyAgICAgICAgRm9yIGV4YW1wbGUsIGF1ZGlvVGFnLCBzb3VyY2VUYWcsIHRy YWNrVGFnIGFuZCBzbyBvbi4gSW4gdGhhdCBjYXNlLCBjcmFzaCBvY2N1cnMgd2hlbiBjYXN0aW5n CisgICAgICAgIGZyb20gbnVsbCB0byBhIHZhbGlkIEhUTUwgY2hpbGQgRWxlbWVudC4KKworICAg ICAgICBUZXN0OiBmYXN0L21lZGlhL21lZGlhLWRpc2FibGUtY3Jhc2guaHRtbAorCisgICAgICAg ICogZG9tL21ha2VfbmFtZXMucGw6CisgICAgICAgIChwcmludENvbnN0cnVjdG9ySW50ZXJpb3Ip OgorCiAyMDEzLTEwLTAzICBBbmRlcnMgQ2FybHNzb24gIDxhbmRlcnNjYUBhcHBsZS5jb20+CiAK ICAgICAgICAgQXNzZXJ0IHRoYXQgd2UgZG9uJ3QgdHJ5IHRvIGluZGV4IHBhc3QgdGhlIGVuZCBv ZiB0aGUgbV9jb3JlVGV4dEluZGljZXMgYXJyYXkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2RvbS9tYWtlX25hbWVzLnBsIGIvU291cmNlL1dlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwKaW5k ZXggMTUzNTBiMmNkZWU4NjMyYzE3NjI0NzZjMjZlZGNiOTYxYjFmNjYzNC4uOTQyNmRiNzBiODQ0 OGJkNjI4NDg3OTBmYmQ3ZGJlZGQ3NDkzNDBlMSAxMDA3NTUKLS0tIGEvU291cmNlL1dlYkNvcmUv ZG9tL21ha2VfbmFtZXMucGwKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwK QEAgLTQwMSw4ICs0MDEsOCBAQCBzdWIgcHJpbnRDb25zdHJ1Y3RvckludGVyaW9yCiAgICAgICAg IHByaW50IEYgPDxFTkQKICAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBkb2N1bWVudC5zZXR0aW5n cygpOwogICAgIGlmICghTWVkaWFQbGF5ZXI6OmlzQXZhaWxhYmxlKCkgfHwgKHNldHRpbmdzICYm ICFzZXR0aW5ncy0+bWVkaWFFbmFibGVkKCkpKQotICAgICAgICByZXR1cm4gMDsKLSAgICAKKyAg ICAgICAgcmV0dXJuICRwYXJhbWV0ZXJze2ZhbGxiYWNrSW50ZXJmYWNlTmFtZX06OmNyZWF0ZSh0 YWdOYW1lLCBkb2N1bWVudCk7CisKIEVORAogOwogICAgIH0KQEAgLTEwODUsNyArMTA4NSw3IEBA IHN0YXRpYyBKU0RPTVdyYXBwZXIqIGNyZWF0ZSR7SlNJbnRlcmZhY2VOYW1lfVdyYXBwZXIoRXhl Y1N0YXRlKiBleGVjLCBKU0RPTUdsb2JhCiB7CiAgICAgU2V0dGluZ3MqIHNldHRpbmdzID0gZWxl bWVudC0+ZG9jdW1lbnQoKS5zZXR0aW5ncygpOwogICAgIGlmICghTWVkaWFQbGF5ZXI6OmlzQXZh aWxhYmxlKCkgfHwgKHNldHRpbmdzICYmICFzZXR0aW5ncy0+bWVkaWFFbmFibGVkKCkpKQotICAg ICAgICByZXR1cm4gQ1JFQVRFX0RPTV9XUkFQUEVSKGV4ZWMsIGdsb2JhbE9iamVjdCwgJHBhcmFt ZXRlcnN7bmFtZXNwYWNlfUVsZW1lbnQsIGVsZW1lbnQuZ2V0KCkpOworICAgICAgICByZXR1cm4g Q1JFQVRFX0RPTV9XUkFQUEVSKGV4ZWMsIGdsb2JhbE9iamVjdCwgJHBhcmFtZXRlcnN7ZmFsbGJh Y2tKU0ludGVyZmFjZU5hbWV9LCBlbGVtZW50LmdldCgpKTsKICAgICByZXR1cm4gQ1JFQVRFX0RP TV9XUkFQUEVSKGV4ZWMsIGdsb2JhbE9iamVjdCwgJHtKU0ludGVyZmFjZU5hbWV9LCBlbGVtZW50 LmdldCgpKTsKIH0KIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGYzY2ZmYWQ3YmM5OWU5ZjA5NThhNmFlYzFjNzk3ZWY4ZGZj YWJkM2YuLjE1NTQ5NGY1MmVhMjYwOWU5NDZiYTU1MjVkZDg5YzVmMThjOGRkYjggMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxNSBAQAorMjAxMy0xMC0wNCAgR3l1eW91bmcgS2ltICA8Z3l1eW91bmcua2ltQHNh bXN1bmcuY29tPgorCisgICAgICAgIFJldHVybiBhIGZhbGxiYWNrIGVsZW1lbnQgd2hlbiBNZWRp YVBsYXllciBpc24ndCBhdmFpbGFibGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTEyMDI5NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIE9yaWdpbmFsIEF1dGhvciBpcyBaYW4gRG9iZXJzZWsoemRvYmVyc2Vr QGlnYWxpYS5jb20pCisKKyAgICAgICAgKiBmYXN0L21lZGlhL21lZGlhLWRpc2FibGUtY3Jhc2gt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L21lZGlhL21lZGlhLWRpc2FibGUt Y3Jhc2guaHRtbDogQWRkZWQuCisKIDIwMTMtMTAtMDMgIENocmlzdG9waGUgRHVtZXogIDxjaC5k dW1lekBzaXNhLnNhbXN1bmcuY29tPgogCiAgICAgICAgIEZpeCB0aGUgSFRNTFNlbGVjdEVsZW1l bnQucHJvdG90eXBlLnJlbW92ZSgpIG1ldGhvZApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC9tZWRpYS9tZWRpYS1kaXNhYmxlLWNyYXNoLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zh c3QvbWVkaWEvbWVkaWEtZGlzYWJsZS1jcmFzaC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDQ0 YzM2MmI4NGM4MjFkZmEzOTIzMmRiNmMyYzYyZjc2OTg2Y2Q1NwotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvbWVkaWEvbWVkaWEtZGlzYWJsZS1jcmFzaC1leHBlY3RlZC50eHQK QEAgLTAsMCArMSBAQAorVGhlIHRlc3QgcGFzc2VzIGlmIGl0IGRvZXNuJ3QgY3Jhc2guCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L21lZGlhL21lZGlhLWRpc2FibGUtY3Jhc2guaHRtbCBi L0xheW91dFRlc3RzL2Zhc3QvbWVkaWEvbWVkaWEtZGlzYWJsZS1jcmFzaC5odG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjU3Yzg5NTk0ZjY3NzdmNGRiYjcyY2U5MmI3YmJmZWRhYWRjOTY5MTAKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L21lZGlhL21lZGlhLWRpc2FibGUtY3Jhc2guaHRtbApA QCAtMCwwICsxLDIyIEBACis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdD4KK2Z1bmN0aW9uIHRlc3Qo KSB7CisgICAgaWYgKHdpbmRvdy50ZXN0UnVubmVyKQorICAgICAgICB0ZXN0UnVubmVyLmR1bXBB c1RleHQoKTsKKworICAgIGlmICh3aW5kb3cuaW50ZXJuYWxzKQorICAgICAgICB3aW5kb3cuaW50 ZXJuYWxzLnNldHRpbmdzLnNldE1lZGlhRW5hYmxlZChmYWxzZSk7CisKKyAgICB2YXIgYXVkaW9F bGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiYXVkaW8iKTsKKyAgICBhdWRpb0VsZW1l bnQgPSBudWxsOworCisgICAgaWYgKHdpbmRvdy5HQ0NvbnRyb2xsZXIpCisgICAgICAgIEdDQ29u dHJvbGxlci5jb2xsZWN0KCk7Cit9Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0i dGVzdCgpIj4KK1RoZSB0ZXN0IHBhc3NlcyBpZiBpdCBkb2Vzbid0IGNyYXNoLgorPC9ib2R5Pgor PC9odG1sPgo= 213445 2013-10-05 00:22:30 -0700 2013-10-05 00:53:17 -0700 Patch bug-120297-20131005002229.patch text/plain 5350 darin U3VidmVyc2lvbiBSZXZpc2lvbjogMTU2OTQ4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTU2YmRlYWY1ZjYxNDVl Zjg0MGU0YjE0NDQ4NTExMDI1NmYzZjAzZS4uNTEzMzg0YWUwNzNiNWNkYzQxNjExNGYzZjNkZWVm Njg1NzAxOTk4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEzLTEwLTA1ICBEYXJp biBBZGxlciAgPGRhcmluQGFwcGxlLmNvbT4KKworICAgICAgICBOZWVkIHRvIGNoZWNrIGlmIHNv bWUgSFRNTCBjaGlsZCBlbGVtZW50cyBhcmUgSFRNTFVua25vd25FbGVtZW50CisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjAyOTcKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGRvbS9tYWtlX25hbWVzLnBs OgorICAgICAgICAocHJpbnRDb25zdHJ1Y3RvckludGVyaW9yKTogQWRkZWQgYWRkaXRpb25hbCBj b21tZW50cyBhYm91dCB0aGUKKyAgICAgICAgd3JhcHBlck9ubHlJZk1lZGlhSXNBdmFpbGFibGUg ZmVhdHVyZS4KKyAgICAgICAgKHByaW50VHlwZUhlbHBlcnMpOiBBZGRlZCBhbiBpc0hUTUxVbmtu b3duRWxlbWVudCBjaGVjayB0byB0aGUgY2hlY2sgaGVscGVyCisgICAgICAgIGZ1bmN0aW9ucyBm b3IgdGFncyB3aXRoIHRoZSB3cmFwcGVyT25seUlmTWVkaWFJc0F2YWlsYWJsZSBmZWF0dXJlLgor ICAgICAgICAocHJpbnRXcmFwcGVyRnVuY3Rpb25zKTogSW5zdGVhZCBvZiByZWRvaW5nIHRoZSBt ZWRpYSBwbGF5ZXIgY2hlY2sgYW5kIHRoZQorICAgICAgICBzZXR0aW5ncyBjaGVjaywgYW5kIHBv c3NpYmx5IG1ha2luZyBhIHdyYXBwZXIgb2YgdGhlIHdyb25nIHR5cGUsIGNhbGwKKyAgICAgICAg aXNIVE1Vbmtub3duRWxlbWVudCwgZ3VhcmFudGVlaW5nIHRoYXQgdGhlIHdyYXBwZXIgd2lsbCBt YXRjaCB0aGUgZWxlbWVudAorICAgICAgICBpdCBpcyB3cmFwcGluZy4KKworICAgICAgICAqIGh0 bWwvSFRNTEVsZW1lbnQuaDogTW92ZSBIVE1MRWxlbWVudFR5cGVIZWxwZXJzLmggdG8gdGhlIGJv dHRvbSBvZiB0aGUKKyAgICAgICAgZmlsZSBzbyB0aGF0IGZ1bmN0aW9ucyBmcm9tIHRoYXQgZmls ZSBjYW4gYmUgdXNlIHRoZSBIVE1MRWxlbWVudCBjbGFzcyBhbmQKKyAgICAgICAgb3RoZXIgdGhp bmdzIGRlZmluZWQgaW4gdGhpcyBmaWxlLgorCiAyMDEzLTEwLTA0ICBEYXJpbiBBZGxlciAgPGRh cmluQGFwcGxlLmNvbT4KIAogICAgICAgICB0ZXh0LXRyYW5zZm9ybTogbG93ZXJjYXNlIGlzIG5v dCBsYW5nLWRlcGVuZGVudCAoVHVya2lzaCBsYW5ndWFnZXMgOiB0cixheikKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2RvbS9tYWtlX25hbWVzLnBsIGIvU291cmNlL1dlYkNvcmUvZG9tL21h a2VfbmFtZXMucGwKaW5kZXggMTUzNTBiMmNkZWU4NjMyYzE3NjI0NzZjMjZlZGNiOTYxYjFmNjYz NC4uMDVmNzI4Y2Q5MTA1MGU5YjI4ZDFjMzcyZWU2NWFlYTdjZWI4OTk3MiAxMDA3NTUKLS0tIGEv U291cmNlL1dlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwKKysrIGIvU291cmNlL1dlYkNvcmUvZG9t L21ha2VfbmFtZXMucGwKQEAgLTM5Nyw2ICszOTcsMTAgQEAgc3ViIHByaW50Q29uc3RydWN0b3JJ bnRlcmlvcgogICAgIG15ICgkRiwgJHRhZ05hbWUsICRpbnRlcmZhY2VOYW1lLCAkY29uc3RydWN0 b3JUYWdOYW1lKSA9IEBfOwogCiAgICAgIyBIYW5kbGUgbWVkaWEgZWxlbWVudHMuCisgICAgIyBO b3RlIHRoYXQgd3JhcHBlck9ubHlJZk1lZGlhSXNBdmFpbGFibGUgaXMgYSBtaXNub21lciwgYmVj YXVzZSBtZWRpYSBhdmFpbGFiaWxpdHkKKyAgICAjIGRvZXMgbm90IGp1c3QgY29udHJvbCB0aGUg d3JhcHBlcjsgaXQgY29udHJvbHMgdGhlIGVsZW1lbnQgb2JqZWN0IHRoYXQgaXMgY3JlYXRlZC4K KyAgICAjIEZJWE1FOiBDb3VsZCB3ZSBpbnN0ZWFkIGRvIHRoaXMgZW50aXJlbHkgaW4gdGhlIHdy YXBwZXIsIGFuZCB1c2UgY3VzdG9tIHdyYXBwZXJzCisgICAgIyBpbnN0ZWFkIG9mIGhhdmluZyBh bGwgdGhlIHN1cHBvcnQgZm9yIHRoaXMgaGVyZSBpbiB0aGlzIHNjcmlwdD8KICAgICBpZiAoJGVu YWJsZWRUYWdzeyR0YWdOYW1lfXt3cmFwcGVyT25seUlmTWVkaWFJc0F2YWlsYWJsZX0pIHsKICAg ICAgICAgcHJpbnQgRiA8PEVORAogICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IGRvY3VtZW50LnNl dHRpbmdzKCk7CkBAIC02MjMsNyArNjI3LDE3IEBAIHN1YiBwcmludFR5cGVIZWxwZXJzCiAgICAg ICAgIG15ICRjaGVja0hlbHBlciA9ICJpcyRjbGFzcyI7CiAKICAgICAgICAgcHJpbnQgRiAiY2xh c3MgJGNsYXNzO1xuIjsKLSAgICAgICAgcHJpbnQgRiAiaW5saW5lIGJvb2wgJGNoZWNrSGVscGVy KGNvbnN0IEVsZW1lbnQmIGVsZW1lbnQpIHsgcmV0dXJuIGVsZW1lbnQuaGFzVGFnTmFtZSgiLiRw YXJhbWV0ZXJze25hbWVzcGFjZX0uIk5hbWVzOjoiLiRuYW1lLiJUYWcpOyB9XG4iOworICAgICAg ICBpZiAoJHBhcnNlZFRhZ3N7JG5hbWV9e3dyYXBwZXJPbmx5SWZNZWRpYUlzQXZhaWxhYmxlfSkg eworICAgICAgICAgICAgIyBXZSBuZWVkIHRvIGNoZWNrIGZvciBIVE1MVW5rbm93bkVsZW1lbnQg aWYgaXQgbWlnaHQgaGF2ZSBiZWVuIGNyZWF0ZWQgYnkgdGhlIGZhY3RvcnkuCisgICAgICAgICAg ICBwcmludCBGIDw8RU5ECitpbmxpbmUgYm9vbCAkY2hlY2tIZWxwZXIoY29uc3QgSFRNTEVsZW1l bnQmIGVsZW1lbnQpIHsgcmV0dXJuICFlbGVtZW50LmlzSFRNTFVua25vd25FbGVtZW50KCkgJiYg ZWxlbWVudC5oYXNMb2NhbE5hbWUoJHBhcmFtZXRlcnN7bmFtZXNwYWNlfU5hbWVzOjoke25hbWV9 VGFnKTsgfQoraW5saW5lIGJvb2wgJGNoZWNrSGVscGVyKGNvbnN0IEhUTUxFbGVtZW50KiBlbGVt ZW50KSB7IHJldHVybiAkY2hlY2tIZWxwZXIoKmVsZW1lbnQpOyB9CitpbmxpbmUgYm9vbCAkY2hl Y2tIZWxwZXIoY29uc3QgRWxlbWVudCYgZWxlbWVudCkgeyByZXR1cm4gaXNIVE1MRWxlbWVudChl bGVtZW50KSAmJiAkY2hlY2tIZWxwZXIodG9IVE1MRWxlbWVudChlbGVtZW50KSk7IH0KK0VORAor ICAgICAgICAgICAgOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgcHJpbnQgRiAiaW5s aW5lIGJvb2wgJGNoZWNrSGVscGVyKGNvbnN0IEVsZW1lbnQmIGVsZW1lbnQpIHsgcmV0dXJuIGVs ZW1lbnQuaGFzVGFnTmFtZSgkcGFyYW1ldGVyc3tuYW1lc3BhY2V9TmFtZXM6OiR7bmFtZX1UYWcp OyB9XG4iOworICAgICAgICB9CiAgICAgICAgIHByaW50IEYgImlubGluZSBib29sICRjaGVja0hl bHBlcihjb25zdCBFbGVtZW50KiBlbGVtZW50KSB7IEFTU0VSVChlbGVtZW50KTsgcmV0dXJuICRj aGVja0hlbHBlcigqZWxlbWVudCk7IH1cbiI7CiAgICAgICAgIHByaW50IEYgImlubGluZSBib29s ICRjaGVja0hlbHBlcihjb25zdCBOb2RlKiBub2RlKSB7IEFTU0VSVChub2RlKTsgcmV0dXJuIG5v ZGUtPmlzRWxlbWVudE5vZGUoKSAmJiAkY2hlY2tIZWxwZXIodG9FbGVtZW50KG5vZGUpKTsgfVxu IjsKICAgICAgICAgcHJpbnQgRiAiaW5saW5lIGJvb2wgJGNoZWNrSGVscGVyKGNvbnN0IE5vZGUm IG5vZGUpIHsgcmV0dXJuIG5vZGUuaXNFbGVtZW50Tm9kZSgpICYmICRjaGVja0hlbHBlcih0b0Vs ZW1lbnQobm9kZSkpOyB9XG4iOwpAQCAtMTA3NywyMCArMTA5MSwxNyBAQCBzdWIgcHJpbnRXcmFw cGVyRnVuY3Rpb25zCiAgICAgICAgICAgICBwcmludCBGICIjaWYgJHtjb25kaXRpb25hbFN0cmlu Z31cblxuIjsKICAgICAgICAgfQogCi0gICAgICAgICMgSGFjayBmb3IgdGhlIG1lZGlhIHRhZ3MK LSAgICAgICAgIyBGSVhNRTogVGhpcyBzaG91bGQgaGF2ZSBiZWVuIGRvbmUgdmlhIGEgQ3VzdG9t V3JhcHBlciBhdHRyaWJ1dGUgYW5kIGEgc2VwYXJhdGUgKkN1c3RvbSBmaWxlLgogICAgICAgICBp ZiAoJGVuYWJsZWRUYWdzeyR0YWdOYW1lfXt3cmFwcGVyT25seUlmTWVkaWFJc0F2YWlsYWJsZX0p IHsKICAgICAgICAgICAgIHByaW50IEYgPDxFTkQKIHN0YXRpYyBKU0RPTVdyYXBwZXIqIGNyZWF0 ZSR7SlNJbnRlcmZhY2VOYW1lfVdyYXBwZXIoRXhlY1N0YXRlKiBleGVjLCBKU0RPTUdsb2JhbE9i amVjdCogZ2xvYmFsT2JqZWN0LCBQYXNzUmVmUHRyPCRwYXJhbWV0ZXJze25hbWVzcGFjZX1FbGVt ZW50PiBlbGVtZW50KQogewotICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IGVsZW1lbnQtPmRvY3Vt ZW50KCkuc2V0dGluZ3MoKTsKLSAgICBpZiAoIU1lZGlhUGxheWVyOjppc0F2YWlsYWJsZSgpIHx8 IChzZXR0aW5ncyAmJiAhc2V0dGluZ3MtPm1lZGlhRW5hYmxlZCgpKSkKKyAgICBpZiAoZWxlbWVu dC0+aXNIVE1MVW5rbm93bkVsZW1lbnQoKSkKICAgICAgICAgcmV0dXJuIENSRUFURV9ET01fV1JB UFBFUihleGVjLCBnbG9iYWxPYmplY3QsICRwYXJhbWV0ZXJze25hbWVzcGFjZX1FbGVtZW50LCBl bGVtZW50LmdldCgpKTsKICAgICByZXR1cm4gQ1JFQVRFX0RPTV9XUkFQUEVSKGV4ZWMsIGdsb2Jh bE9iamVjdCwgJHtKU0ludGVyZmFjZU5hbWV9LCBlbGVtZW50LmdldCgpKTsKIH0KIAogRU5ECi0g ICAgOworICAgICAgICAgICAgOwogICAgICAgICB9IGVsc2lmICgkZW5hYmxlZFRhZ3N7JHRhZ05h bWV9e3J1bnRpbWVDb25kaXRpb25hbH0pIHsKICAgICAgICAgICAgIG15ICRydW50aW1lQ29uZGl0 aW9uYWwgPSAkZW5hYmxlZFRhZ3N7JHRhZ05hbWV9e3J1bnRpbWVDb25kaXRpb25hbH07CiAgICAg ICAgICAgICBwcmludCBGIDw8RU5ECmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hU TUxFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxFbGVtZW50LmgKaW5kZXggY2Uz ZGYzNTA5MmI2MWNkM2NiODA1YTZmNzlhYzE1NzdlNWY0OGE3My4uNmNlYTRkODZiZDBjMTI2MzMz YWQyOTM2MWFiZDJkMGQ2YjNhN2MxNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEVsZW1lbnQuaApAQCAt MjUsOCArMjUsNiBAQAogCiAjaW5jbHVkZSAiU3R5bGVkRWxlbWVudC5oIgogCi0jaW5jbHVkZSAi SFRNTEVsZW1lbnRUeXBlSGVscGVycy5oIgotCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNz IERvY3VtZW50RnJhZ21lbnQ7CkBAIC0xNDYsNCArMTQ0LDYgQEAgRUxFTUVOVF9UWVBFX0NBU1RT KEhUTUxFbGVtZW50KQogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKKyNpbmNsdWRlICJIVE1M RWxlbWVudFR5cGVIZWxwZXJzLmgiCisKICNlbmRpZiAvLyBIVE1MRWxlbWVudF9oCg==