76354 2012-01-15 18:26:07 -0800 [Shadow DOM] ShadowRoot should be constructable 2012-01-29 19:48:01 -0800 1 1 1 Unclassified WebKit DOM 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 76353 76693 1 morrita hayato abarth dglazkov haraken hayato japhet ojan peter webkit.review.bot oldest_to_newest 536320 0 morrita 2012-01-15 18:26:07 -0800 I'd like to keep this separated from Bug 76353 because the constructor needs to care about some nontrivial stuff like nesting. I don't think we need to support nesting at first, but at least we need to guard against it. 540414 1 hayato 2012-01-23 00:47:35 -0800 I agree that we don't need to support nesting at first, but could you tell me what is the issue of nesting? Is it related to the rendering or something else? (In reply to comment #0) > I'd like to keep this separated from Bug 76353 > because the constructor needs to care about some nontrivial stuff like nesting. > I don't think we need to support nesting at first, but at least we need to guard against it. 540467 2 123537 hayato 2012-01-23 03:49:19 -0800 Created attachment 123537 wip. based on dominic's patch 540710 3 123537 morrita 2012-01-23 11:44:36 -0800 Comment on attachment 123537 wip. based on dominic's patch View in context: https://bugs.webkit.org/attachment.cgi?id=123537&action=review > Source/WebCore/dom/ShadowRoot.idl:32 > + CustomConstructFunction I guess we don't need custom constructor and can use CallWith=ScriptExceptionContext instead. ScriptExecutionContext is actually a Document object, which provides frame() to retrieve the frame pointer. > Source/WebCore/page/DOMWindow.idl:401 > + attribute [CustomGetter, Conditional=SHADOW_DOM] ShadowRootConstructor ShadowRoot EnabledAtRuntime? 541247 4 hayato 2012-01-24 04:47:25 -0800 Thank you for the review. (In reply to comment #3) > (From update of attachment 123537 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=123537&action=review > > > Source/WebCore/dom/ShadowRoot.idl:32 > > + CustomConstructFunction > > I guess we don't need custom constructor and can use CallWith=ScriptExceptionContext instead. > ScriptExecutionContext is actually a Document object, which provides frame() to retrieve the frame pointer. Could you clarify how we can use SecriptExecutionContext here if possible? I am not strongly familiar with how to use it. > > > Source/WebCore/page/DOMWindow.idl:401 > > + attribute [CustomGetter, Conditional=SHADOW_DOM] ShadowRootConstructor ShadowRoot > > EnabledAtRuntime? OK. Let me fix. Two more things: - I'll rename ShadowRoot to WebKitShadowRoot as discussed in another thread. - Do you think we need to support JavaScriptCore in the same patch? 541390 5 morrita 2012-01-24 09:33:08 -0800 > > I guess we don't need custom constructor and can use CallWith=ScriptExceptionContext instead. > > ScriptExecutionContext is actually a Document object, which provides frame() to retrieve the frame pointer. > > Could you clarify how we can use SecriptExecutionContext here if possible? I am not strongly familiar with how to use it. I'm sorry for the lack of clarity... The WebKItIDL support "CallWith" attribute for method invocation (and for the constructor IIRC). You can see an example in page/History.idl. Specifying the attribute, the script generates the code which passes ScriptExceptionContext as a parameter of the native method call. The given ScriptExceptionContext is actually a document. So we can retrieve a Fame object associated with the document. > > > > > > Source/WebCore/page/DOMWindow.idl:401 > > > + attribute [CustomGetter, Conditional=SHADOW_DOM] ShadowRootConstructor ShadowRoot > > > > EnabledAtRuntime? > > OK. Let me fix. > > Two more things: > - I'll rename ShadowRoot to WebKitShadowRoot as discussed in another thread. Thanks! > - Do you think we need to support JavaScriptCore in the same patch? I think it can be done in a separate patch. But I expect we don't need any custom code and it's done automatically. CC-ing Haraken may know something about this. 541464 6 123537 haraken 2012-01-24 10:42:32 -0800 Comment on attachment 123537 wip. based on dominic's patch View in context: https://bugs.webkit.org/attachment.cgi?id=123537&action=review >>> Source/WebCore/dom/ShadowRoot.idl:32 >>> + CustomConstructFunction >> >> I guess we don't need custom constructor and can use CallWith=ScriptExceptionContext instead. >> ScriptExecutionContext is actually a Document object, which provides frame() to retrieve the frame pointer. > > Could you clarify how we can use SecriptExecutionContext here if possible? I am not strongly familiar with how to use it. EventSource.idl is a good example. It uses CallWith=ScriptExecutionContext for the constructor. You can just write interface [Conditional=SHADOW_DOM, EnabledAtRuntime=shadowDOM, V8Constructor, CallWith=ScriptExecutionContext] ShadowRoot : Node { ... } Then, the following code will be generated. (See src/out/Debug/obj/gen/webcore/bindings/V8ShadowRoot.cpp.) RefPtr<ShadowRoot> impl = ShadowRoot::create(context); .... You can retrieve the frame pointer from |context| in ShadowRoot::create(). 541529 7 123537 webkit.review.bot 2012-01-24 11:47:11 -0800 Comment on attachment 123537 wip. based on dominic's patch Attachment 123537 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/11344018 New failing tests: fast/dom/dom-constructors.html fast/js/constructor.html fast/dom/Window/window-lookup-precedence.html fast/dom/global-constructors.html 542041 8 123892 hayato 2012-01-24 23:42:12 -0800 Created attachment 123892 Add ShadowRoot consturctor as WebKitShadowRoot 542058 9 hayato 2012-01-25 00:53:10 -0800 Thank you for the review. (In reply to comment #5) > > > I guess we don't need custom constructor and can use CallWith=ScriptExceptionContext instead. > > > ScriptExecutionContext is actually a Document object, which provides frame() to retrieve the frame pointer. > > > > Could you clarify how we can use SecriptExecutionContext here if possible? I am not strongly familiar with how to use it. > > I'm sorry for the lack of clarity... > > The WebKItIDL support "CallWith" attribute for method invocation (and for the constructor IIRC). > You can see an example in page/History.idl. > Specifying the attribute, the script generates the code which passes > ScriptExceptionContext as a parameter of the native method call. > The given ScriptExceptionContext is actually a document. > So we can retrieve a Fame object associated with the document. Thank you for the explanation. After I implemented ShadowRoot::create(ScriptExecutionContext*, Element*), I noticed that we don't need ScriptExecutionContext because we can retrieve Document object which is required for ShadowRoot's constructor, from the given shadowHost Element. Aha! > > > EnabledAtRuntime? Done. 542164 10 123892 haraken 2012-01-25 03:48:40 -0800 Comment on attachment 123892 Add ShadowRoot consturctor as WebKitShadowRoot View in context: https://bugs.webkit.org/attachment.cgi?id=123892&action=review > Source/WebCore/dom/ShadowRoot.cpp:63 > + ASSERT(!ec); Is this OK? If setShadowRoot() can raise an exception, you should add the [ConstructorRaisesException] IDL to handle the exception. Then the signature of ShadowRoot::create() would be ShadowRoot::create(Element*, ExceptionCode&). Please look at EventSource.idl and EventSource::create() for reference. 542171 11 hayato 2012-01-25 04:02:28 -0800 Thank you for the review. (In reply to comment #10) > (From update of attachment 123892 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=123892&action=review > > > Source/WebCore/dom/ShadowRoot.cpp:63 > > + ASSERT(!ec); > > Is this OK? If setShadowRoot() can raise an exception, you should add the [ConstructorRaisesException] IDL to handle the exception. Then the signature of ShadowRoot::create() would be ShadowRoot::create(Element*, ExceptionCode&). Please look at EventSource.idl and EventSource::create() for reference. Element::setShadowRoot() should not raise Exception in this code path since validateShadowRoot in Element.cpp always return true in this case. But I agree we should change the signature since we might change the semantic of Element::setShadowRoot in the future. It becomes robust if we return ExceptionCode as is. Thank you! Let me update the patch. 542179 12 123919 hayato 2012-01-25 04:21:55 -0800 Created attachment 123919 Use ExceptionCode 542185 13 hayato 2012-01-25 04:29:01 -0800 I've found the generated code doesn't check null-pointer for in-parameter. 'new WebKitShadowRoot(undefined) ' simply crashes. Let me handle this case. 542199 14 123924 hayato 2012-01-25 04:54:26 -0800 Created attachment 123924 Validate input Element 542218 15 123924 haraken 2012-01-25 06:13:30 -0800 Comment on attachment 123924 Validate input Element View in context: https://bugs.webkit.org/attachment.cgi?id=123924&action=review > Source/WebCore/dom/ShadowRoot.cpp:59 > + ec = TYPE_MISMATCH_ERR; This should be HIERARCHY_REQUEST_ERR. https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#shadow-root-object > LayoutTests/fast/dom/shadow/shadow-root-js-api.html:15 > +shouldThrow("new WebKitShadowRoot()"); > +shouldThrow("new WebKitShadowRoot(undefined)"); > +shouldThrow("new WebKitShadowRoot(1)"); Can you add more test cases around 'might-be Nullable' data, like WebKitShadowRoot(''), WebKitShadowRoot(null), WebKitShadowRoot('null'), WebKitShadowRoot('undefined') 542229 16 hayato 2012-01-25 06:45:04 -0800 (In reply to comment #15) > (From update of attachment 123924 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=123924&action=review > > > Source/WebCore/dom/ShadowRoot.cpp:59 > > + ec = TYPE_MISMATCH_ERR; > > This should be HIERARCHY_REQUEST_ERR. > https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#shadow-root-object Oh. Nice catch. I'll fix it in the next patch. But I think TYPE_MISMATCH_ERR is more appropriate here. I might file a bug for the spec. > > > LayoutTests/fast/dom/shadow/shadow-root-js-api.html:15 > > +shouldThrow("new WebKitShadowRoot()"); > > +shouldThrow("new WebKitShadowRoot(undefined)"); > > +shouldThrow("new WebKitShadowRoot(1)"); > > Can you add more test cases around 'might-be Nullable' data, like WebKitShadowRoot(''), WebKitShadowRoot(null), WebKitShadowRoot('null'), WebKitShadowRoot('undefined') Such tests don't have much meaning here because it proves only our IDL's ability of converting 'nullable' data to null. I think there are existing tests which cover such cases. I think the following 3 tests are enough here as error cases of ShadowRoot' constructor API: new WebKitShadowRoot(); // Test for args' length 0 new WebKitShadowRoot(null); // Test for null new WebKitShadowRoot(1); // Test for incompatible type. 542244 17 123924 haraken 2012-01-25 07:22:15 -0800 Comment on attachment 123924 Validate input Element View in context: https://bugs.webkit.org/attachment.cgi?id=123924&action=review >>> Source/WebCore/dom/ShadowRoot.cpp:59 >>> + ec = TYPE_MISMATCH_ERR; >> >> This should be HIERARCHY_REQUEST_ERR. >> https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#shadow-root-object > > Oh. Nice catch. I'll fix it in the next patch. But I think TYPE_MISMATCH_ERR is more appropriate here. I might file a bug for the spec. Makes sense to file and discuss the error type. I think SYNTAX_ERR is another candidate. Actually, what error should be returned in such cases is different from spec to spec (e.g. exceptions in Indexed DB: http://www.w3.org/TR/IndexedDB/#exceptions). >>> LayoutTests/fast/dom/shadow/shadow-root-js-api.html:15 >>> +shouldThrow("new WebKitShadowRoot(1)"); >> >> Can you add more test cases around 'might-be Nullable' data, like WebKitShadowRoot(''), WebKitShadowRoot(null), WebKitShadowRoot('null'), WebKitShadowRoot('undefined') > > Such tests don't have much meaning here because it proves only our IDL's ability of converting 'nullable' data to null. I think there are existing tests which cover such cases. > > I think the following 3 tests are enough here as error cases of ShadowRoot' constructor API: > new WebKitShadowRoot(); // Test for args' length 0 > new WebKitShadowRoot(null); // Test for null > new WebKitShadowRoot(1); // Test for incompatible type. OK. But let's add WebKitShadowRoot(undefined). Basically, I guess it is important to clarify (1) the behavior when the argument is missing (it depends on [Optional]), (2) the behavior when the argument is null (it depends on [ConvertNullToNullString]), and (3) the behavior when the argument is undefined (it depends on [ConvertNullOrUndefinedToNullString]). 542459 18 123924 abarth 2012-01-25 11:05:23 -0800 Comment on attachment 123924 Validate input Element View in context: https://bugs.webkit.org/attachment.cgi?id=123924&action=review > Source/WebCore/dom/ShadowRoot.cpp:65 > + if (!element->document()) { > + ec = WRONG_DOCUMENT_ERR; > + return 0; > + } Are you sure this can happen? Do you have a test that demonstrates it? 542500 19 123924 morrita 2012-01-25 11:48:04 -0800 Comment on attachment 123924 Validate input Element View in context: https://bugs.webkit.org/attachment.cgi?id=123924&action=review > Source/WebCore/dom/ShadowRoot.cpp:56 > +PassRefPtr<ShadowRoot> ShadowRoot::create(Element* element, ExceptionCode& ec) Please ensure that |element| has no shadow or throw an exception. At this time we don't support nested shadow. >>>> Source/WebCore/dom/ShadowRoot.cpp:59 >>>> + ec = TYPE_MISMATCH_ERR; >>> >>> This should be HIERARCHY_REQUEST_ERR. >>> https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#shadow-root-object >> >> Oh. Nice catch. I'll fix it in the next patch. But I think TYPE_MISMATCH_ERR is more appropriate here. I might file a bug for the spec. > > Makes sense to file and discuss the error type. I think SYNTAX_ERR is another candidate. Actually, what error should be returned in such cases is different from spec to spec (e.g. exceptions in Indexed DB: http://www.w3.org/TR/IndexedDB/#exceptions). Also, |element| should be always isElementNode(). 542861 20 124059 hayato 2012-01-25 20:57:10 -0800 Created attachment 124059 Update 542864 21 hayato 2012-01-25 21:06:55 -0800 Thank you for the reviews, guys. (In reply to comment #17) > OK. But let's add WebKitShadowRoot(undefined). Basically, I guess it is important to clarify (1) the behavior when the argument is missing (it depends on [Optional]), (2) the behavior when the argument is null (it depends on [ConvertNullToNullString]), and (3) the behavior when the argument is undefined (it depends on [ConvertNullOrUndefinedToNullString]). Okay, I added 'undefined' case and 'null' case. But should we take care such converting rules of IDL here? Since we declare input parameter as Element, generated code always passes correctly-typed Element* (nullable) object and never passes String object, doesn't it? I am afraid that if we add tests for each rule, tests will be tightly coupled with a particular IDL implementation. I mean even if IDL adds a new rule, such as 'NumberZeroToEmptyString', in the future, we don't want to update all existing JavaScript API tests to test for '0', I guess. (In reply to comment #18) > (From update of attachment 123924 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=123924&action=review > > > Source/WebCore/dom/ShadowRoot.cpp:65 > > + if (!element->document()) { > > + ec = WRONG_DOCUMENT_ERR; > > + return 0; > > + } > > Are you sure this can happen? Do you have a test that demonstrates it? Done. Never happens as per Node::document()'s commet. We can assume that Element is never DocmentType node. (In reply to comment #19) > (From update of attachment 123924 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=123924&action=review > > > Source/WebCore/dom/ShadowRoot.cpp:56 > > +PassRefPtr<ShadowRoot> ShadowRoot::create(Element* element, ExceptionCode& ec) > > Please ensure that |element| has no shadow or throw an exception. > At this time we don't support nested shadow. If element has shadowRoot, the old shadowRoot is simply replaced with new ShadowRoot in Element::setShadowRoot, isn't it? I guess you mean 'Hosting Multiple-Shadow Subtrees' in the spec by 'nesting', right? https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#nested-shadow-subtrees I cannot read how to host multiple shadow subtree in the spec. I guess the following is an intended way to host multiple shadow subtree. But the spec must mention it more clearly. var div = document.createElement('div'); var sr1 = new WebKitShadowRoot(div); var sr2 = new WebKitShadowRoot(div); // (*) sr2 is younger ShadowRoot. sr1 is now older ShadowRoot. It this is an intended usage, we have to decide the behavior until we support hosting multiple ShadowRoot when (*) happens. I think we have two options: 1. Replace oldShadowRoot with newShadowRoot as the previous patch does it. 2. Reject and raises DOMException. 2) looks safer for me. So I've updated the patch. > Also, |element| should be always isElementNode(). Done. I've removed isElementNode() check. 542869 22 hayato 2012-01-25 21:25:45 -0800 The correct link to (Hosting Multiple Shadow Subtrees) is here: https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#multiple-shadow-subtrees (In reply to comment #21) > Thank you for the reviews, guys. > > (In reply to comment #17) > > OK. But let's add WebKitShadowRoot(undefined). Basically, I guess it is important to clarify (1) the behavior when the argument is missing (it depends on [Optional]), (2) the behavior when the argument is null (it depends on [ConvertNullToNullString]), and (3) the behavior when the argument is undefined (it depends on [ConvertNullOrUndefinedToNullString]). > > Okay, I added 'undefined' case and 'null' case. But should we take care such converting rules of IDL here? Since we declare input parameter as Element, generated code always passes correctly-typed Element* (nullable) object and never passes String object, doesn't it? > > I am afraid that if we add tests for each rule, tests will be tightly coupled with a particular IDL implementation. I mean even if IDL adds a new rule, such as 'NumberZeroToEmptyString', in the future, we don't want to update all existing JavaScript API tests to test for '0', I guess. > > > (In reply to comment #18) > > (From update of attachment 123924 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=123924&action=review > > > > > Source/WebCore/dom/ShadowRoot.cpp:65 > > > + if (!element->document()) { > > > + ec = WRONG_DOCUMENT_ERR; > > > + return 0; > > > + } > > > > Are you sure this can happen? Do you have a test that demonstrates it? > > Done. Never happens as per Node::document()'s commet. We can assume that Element is never DocmentType node. > > (In reply to comment #19) > > (From update of attachment 123924 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=123924&action=review > > > > > Source/WebCore/dom/ShadowRoot.cpp:56 > > > +PassRefPtr<ShadowRoot> ShadowRoot::create(Element* element, ExceptionCode& ec) > > > > Please ensure that |element| has no shadow or throw an exception. > > At this time we don't support nested shadow. > > If element has shadowRoot, the old shadowRoot is simply replaced with new ShadowRoot in Element::setShadowRoot, isn't it? > > I guess you mean 'Hosting Multiple-Shadow Subtrees' in the spec by 'nesting', right? > https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#nested-shadow-subtrees > > I cannot read how to host multiple shadow subtree in the spec. > I guess the following is an intended way to host multiple shadow subtree. But the spec must mention it more clearly. > var div = document.createElement('div'); > var sr1 = new WebKitShadowRoot(div); > var sr2 = new WebKitShadowRoot(div); // (*) sr2 is younger ShadowRoot. sr1 is now older ShadowRoot. > > It this is an intended usage, we have to decide the behavior until we support hosting multiple ShadowRoot when (*) happens. I think we have two options: > > 1. Replace oldShadowRoot with newShadowRoot as the previous patch does it. > 2. Reject and raises DOMException. > > 2) looks safer for me. So I've updated the patch. > > > > Also, |element| should be always isElementNode(). > > Done. I've removed isElementNode() check. 542880 23 124063 hayato 2012-01-25 22:11:02 -0800 Created attachment 124063 makes sure no side-effects 542908 24 haraken 2012-01-26 00:02:55 -0800 (In reply to comment #21) > (In reply to comment #17) > > OK. But let's add WebKitShadowRoot(undefined). Basically, I guess it is important to clarify (1) the behavior when the argument is missing (it depends on [Optional]), (2) the behavior when the argument is null (it depends on [ConvertNullToNullString]), and (3) the behavior when the argument is undefined (it depends on [ConvertNullOrUndefinedToNullString]). > > Okay, I added 'undefined' case and 'null' case. But should we take care such converting rules of IDL here? Since we declare input parameter as Element, generated code always passes correctly-typed Element* (nullable) object and never passes String object, doesn't it? Ah, yes, right, sorry. As you mentioned before, a missing argument, null and 1 would be enough test cases. Thank you very much for the clarification! 543198 25 dglazkov 2012-01-26 09:20:57 -0800 (In reply to comment #24) > (In reply to comment #21) > > (In reply to comment #17) > > > OK. But let's add WebKitShadowRoot(undefined). Basically, I guess it is important to clarify (1) the behavior when the argument is missing (it depends on [Optional]), (2) the behavior when the argument is null (it depends on [ConvertNullToNullString]), and (3) the behavior when the argument is undefined (it depends on [ConvertNullOrUndefinedToNullString]). > > > > Okay, I added 'undefined' case and 'null' case. But should we take care such converting rules of IDL here? Since we declare input parameter as Element, generated code always passes correctly-typed Element* (nullable) object and never passes String object, doesn't it? > > Ah, yes, right, sorry. As you mentioned before, a missing argument, null and 1 would be enough test cases. Thank you very much for the clarification! Haraken, you wanna give your new reviewership a try? :) 543575 26 morrita 2012-01-26 15:33:41 -0800 (In reply to comment #21) > 1. Replace oldShadowRoot with newShadowRoot as the previous patch does it. > 2. Reject and raises DOMException. > > 2) looks safer for me. So I've updated the patch. I think same. Replacing existing shadow will break stuff, especially build-in shadows like one of <input>. 543586 27 124063 morrita 2012-01-26 15:39:56 -0800 Comment on attachment 124063 makes sure no side-effects View in context: https://bugs.webkit.org/attachment.cgi?id=124063&action=review > Source/WebCore/dom/ShadowRoot.cpp:65 > + return 0; Could you add a test for this path. I guess creating shadow from different document (typically from another frame) would raise an exception. 543776 28 hayato 2012-01-26 20:16:17 -0800 Thank you for the review. (In reply to comment #27) > (From update of attachment 124063 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=124063&action=review > > > Source/WebCore/dom/ShadowRoot.cpp:65 > > + return 0; > > Could you add a test for this path. I guess creating shadow from different document (typically from another frame) would raise an exception. That never happens. See the previous comment for the reason I added this: https://bugs.webkit.org/show_bug.cgi?id=76354#c11 Since we use host's document in creating ShadowRoot, host->document() and shadowRoot->document() is always same. I guess you mean that JavaScript running in outer iframe context calls 'new ShadowRoot(elementInInnerIframe)', right? We don't have clear spec for that case, right? In current implementation, we don't have a logic to reject such a case. We might want to file a bug for the spec for clarity. 544125 29 morrita 2012-01-27 09:37:44 -0800 (In reply to comment #28) > Thank you for the review. > > (In reply to comment #27) > > (From update of attachment 124063 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=124063&action=review > > > > > Source/WebCore/dom/ShadowRoot.cpp:65 > > > + return 0; > > > > Could you add a test for this path. I guess creating shadow from different document (typically from another frame) would raise an exception. > > That never happens. See the previous comment for the reason I added this: > https://bugs.webkit.org/show_bug.cgi?id=76354#c11 Ah, got it. 544128 30 124063 morrita 2012-01-27 09:42:19 -0800 Comment on attachment 124063 makes sure no side-effects View in context: https://bugs.webkit.org/attachment.cgi?id=124063&action=review > LayoutTests/ChangeLog:1 > +2012-01-24 Hayato Ito <hayato@chromium.org> We need to skip this for non-Chromium ports. 544815 31 hayato 2012-01-29 18:15:53 -0800 fast/dom/shadow/shadow-root-js-api.html is already skipped on non-chromium ports in https://bugs.webkit.org/show_bug.cgi?id=76353. Is there any mission ports? EWS looks good so let me try cq+. (In reply to comment #30) > (From update of attachment 124063 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=124063&action=review > > > LayoutTests/ChangeLog:1 > > +2012-01-24 Hayato Ito <hayato@chromium.org> > > We need to skip this for non-Chromium ports. 544839 32 124063 webkit.review.bot 2012-01-29 19:47:52 -0800 Comment on attachment 124063 makes sure no side-effects Clearing flags on attachment: 124063 Committed r106208: <http://trac.webkit.org/changeset/106208> 544840 33 webkit.review.bot 2012-01-29 19:48:01 -0800 All reviewed patches have been landed. Closing bug. 123537 2012-01-23 03:49:19 -0800 2012-01-24 23:42:06 -0800 wip. based on dominic's patch bug-76354-20120123204918.patch text/plain 11874 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1NTkyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZGZiNDI0ZDk3NmNhYzcw YTU2NTQ0NzIxYTEwZWE4ODMxOTM2OWU0Yy4uOWUzYWVkMmQwZjE1OGRkMTczNjgzZTFlNjczMjdk NGVhNTFlN2VhOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDEyLTAxLTIzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgYSBTaGFkb3dSb290 IGNvbnN0cnVjdG9yLCB3aGljaCBpcyBlbmFibGVkIGJ5IFNIQURPV19ET00gZmxhZy4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc2MzU0CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6 CisgICAgICAgICogYmluZGluZ3MvdjgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9tLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlY4RE9NV2luZG93OjpTaGFkb3dSb290QWNjZXNzb3JHZXR0ZXIpOgor ICAgICAgICAqIGJpbmRpbmdzL3Y4L2N1c3RvbS9WOFNoYWRvd1Jvb3RDb25zdHJ1Y3Rvci5jcHA6 IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6djhTaGFkb3dSb290Q29uc3RydWN0b3JDYWxsYmFj ayk6CisgICAgICAgIChXZWJDb3JlOjpWOFNoYWRvd1Jvb3RDb25zdHJ1Y3Rvcjo6R2V0VGVtcGxh dGUpOgorICAgICAgICAqIGJpbmRpbmdzL3Y4L2N1c3RvbS9WOFNoYWRvd1Jvb3RDb25zdHJ1Y3Rv ci5oOiBBZGRlZC4KKyAgICAgICAgKiBkb20vU2hhZG93Um9vdC5pZGw6CisgICAgICAgICogcGFn ZS9ET01XaW5kb3cuaWRsOgorCiAyMDEyLTAxLTIyICBNYXJpbyBTYW5jaGV6IFByYWRhICA8bXNh bmNoZXpAaWdhbGlhLmNvbT4KIAogICAgICAgICBbR1RLXSBBVEsgdGV4dC1jYXJldC1tb3ZlZCBh bmQgdGV4dC1zZWxlY3Rpb24tY2hhbmdlZCBldmVudHMgbm90IGJlaW5nIGVtaXR0ZWQKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUuZ3lwaQppbmRleCAyZjEwOTM3NjgwNzIxZmMzZTgyMzYzZmYzNjI1MWZiOGI3OTRlM2QzLi40 ZTc3OGM5ZDk5OWMzMGUxMGNhZGIzNzI3OTJkOTRiMzBkNGMyZDcwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBp CkBAIC0yMjg2LDYgKzIyODYsOCBAQAogICAgICAgICAgICAgJ2JpbmRpbmdzL3Y4L2N1c3RvbS9W OFNWR1BhdGhTZWdDdXN0b20uY3BwJywKICAgICAgICAgICAgICdiaW5kaW5ncy92OC9jdXN0b20v VjhTY3JpcHRQcm9maWxlQ3VzdG9tLmNwcCcsCiAgICAgICAgICAgICAnYmluZGluZ3MvdjgvY3Vz dG9tL1Y4U2NyaXB0UHJvZmlsZU5vZGVDdXN0b20uY3BwJywKKyAgICAgICAgICAgICdiaW5kaW5n cy92OC9jdXN0b20vVjhTaGFkb3dSb290Q29uc3RydWN0b3IuY3BwJywKKyAgICAgICAgICAgICdi aW5kaW5ncy92OC9jdXN0b20vVjhTaGFkb3dSb290Q29uc3RydWN0b3IuaCcsCiAgICAgICAgICAg ICAnYmluZGluZ3MvdjgvY3VzdG9tL1Y4U3RvcmFnZUN1c3RvbS5jcHAnLAogICAgICAgICAgICAg J2JpbmRpbmdzL3Y4L2N1c3RvbS9WOFN0eWxlU2hlZXRDdXN0b20uY3BwJywKICAgICAgICAgICAg ICdiaW5kaW5ncy92OC9jdXN0b20vVjhTdHlsZVNoZWV0TGlzdEN1c3RvbS5jcHAnLApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9t LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOERPTVdpbmRvd0N1c3Rv bS5jcHAKaW5kZXggYjc0YjI2NDQ2NzRlNGMzNWQ2MjljYjc0ZTExNGQ5MzVjOWRkYTA5MS4uNTVi NmQ0Nzg2MzAyMzY2Yjc0NjUwY2MwNGM4N2YwYzMyYmY2MzE5MyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9tLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhET01XaW5kb3dDdXN0b20uY3BwCkBA IC02MSw2ICs2MSw3IEBACiAjaW5jbHVkZSAiVjhIVE1MQ29sbGVjdGlvbi5oIgogI2luY2x1ZGUg IlY4Tm9kZS5oIgogI2luY2x1ZGUgIlY4UHJveHkuaCIKKyNpbmNsdWRlICJWOFNoYWRvd1Jvb3RD b25zdHJ1Y3Rvci5oIgogI2luY2x1ZGUgIlY4VXRpbGl0aWVzLmgiCiAjaW5jbHVkZSAiV2luZG93 RmVhdHVyZXMuaCIKIApAQCAtNjI3LDQgKzYyOCwxMCBAQCB2ODo6SGFuZGxlPHY4OjpWYWx1ZT4g dG9WOChET01XaW5kb3cqIHdpbmRvdykKICAgICByZXR1cm4gZ2xvYmFsOwogfQogCit2ODo6SGFu ZGxlPHY4OjpWYWx1ZT4gVjhET01XaW5kb3c6OlNoYWRvd1Jvb3RBY2Nlc3NvckdldHRlcih2ODo6 TG9jYWw8djg6OlN0cmluZz4gbmFtZSwgY29uc3Qgdjg6OkFjY2Vzc29ySW5mbyYgaW5mbykKK3sK KyAgICBET01XaW5kb3cqIHdpbmRvdyA9IFY4RE9NV2luZG93Ojp0b05hdGl2ZShpbmZvLkhvbGRl cigpKTsKKyAgICByZXR1cm4gVjhET01XcmFwcGVyOjpnZXRDb25zdHJ1Y3RvcigmVjhTaGFkb3dS b290Q29uc3RydWN0b3I6OmluZm8sIHdpbmRvdyk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNv cmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOFNoYWRv d1Jvb3RDb25zdHJ1Y3Rvci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20v VjhTaGFkb3dSb290Q29uc3RydWN0b3IuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjgzYTE0MDkxNDRlYWZiMTY0 N2FjZjdjOWFkNzdmOWUyOGNkZDI2NDQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy92OC9jdXN0b20vVjhTaGFkb3dSb290Q29uc3RydWN0b3IuY3BwCkBAIC0wLDAg KzEsOTkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoK KyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICog RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8g RVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQor ICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBD T05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0Yg VVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICog VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiVjhTaGFkb3dS b290Q29uc3RydWN0b3IuaCIKKworI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiRnJh bWUuaCIKKyNpbmNsdWRlICJWOEJpbmRpbmcuaCIKKyNpbmNsdWRlICJWOEVsZW1lbnQuaCIKKyNp bmNsdWRlICJWOFByb3h5LmgiCisjaW5jbHVkZSAiVjhTaGFkb3dSb290LmgiCisKKyNpbmNsdWRl IDx3dGYvUmVmUHRyLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworV3JhcHBlclR5cGVJbmZv IFY4U2hhZG93Um9vdENvbnN0cnVjdG9yOjppbmZvID0geyBWOFNoYWRvd1Jvb3RDb25zdHJ1Y3Rv cjo6R2V0VGVtcGxhdGUsIDAsIDAsIDAgfTsKKworc3RhdGljIHY4OjpIYW5kbGU8djg6OlZhbHVl PiB2OFNoYWRvd1Jvb3RDb25zdHJ1Y3RvckNhbGxiYWNrKGNvbnN0IHY4OjpBcmd1bWVudHMmIGFy Z3MpCit7CisgICAgSU5DX1NUQVRTKCJET00uU2hhZG93Um9vdC5Db250cnVjdG9yIik7CisKKyAg ICBpZiAoIWFyZ3MuSXNDb25zdHJ1Y3RDYWxsKCkpCisgICAgICAgIHJldHVybiB0aHJvd0Vycm9y KCJET00gb2JqZWN0IGNvbnN0cnVjdG9yIGNhbm5vdCBiZSBjYWxsZWQgYXMgYSBmdW5jdGlvbi4i LCBWOFByb3h5OjpUeXBlRXJyb3IpOworCisgICAgRnJhbWUqIGZyYW1lID0gVjhQcm94eTo6cmV0 cmlldmVGcmFtZUZvckN1cnJlbnRDb250ZXh0KCk7CisgICAgaWYgKCFmcmFtZSkKKyAgICAgICAg cmV0dXJuIHRocm93RXJyb3IoIlNoYWRvd1Jvb3QgY29uc3RydWN0b3IgYXNzb2NpYXRlZCBmcmFt ZSBpcyB1bmF2YWlsYWJsZSIsIFY4UHJveHk6OlJlZmVyZW5jZUVycm9yKTsKKworICAgIERvY3Vt ZW50KiBkb2N1bWVudCA9IGZyYW1lLT5kb2N1bWVudCgpOworICAgIGlmICghZG9jdW1lbnQpCisg ICAgICAgIHJldHVybiB0aHJvd0Vycm9yKCJTaGFkb3dSb290IGNvbnN0cnVjdG9yIGFzc29jaWF0 ZWQgZG9jdW1lbnQgaXMgdW5hdmFpbGFibGUiLCBWOFByb3h5OjpSZWZlcmVuY2VFcnJvcik7CisK KyAgICAvLyBNYWtlIHN1cmUgdGhlIGRvY3VtZW50IGlzIGFkZGVkIHRvIHRoZSBET00gTm9kZSBt YXAuIE90aGVyd2lzZSwgdGhlIFNoYWRvd1Jvb3QgaW5zdGFuY2UKKyAgICAvLyBtYXkgZW5kIHVw IGJlaW5nIHRoZSBvbmx5IG5vZGUgaW4gdGhlIG1hcCBhbmQgZ2V0IGdhcmJhZ2UtY2NvbGxlY3Rl ZCBwcmVtYXR1cmVseS4KKyAgICB0b1Y4KGRvY3VtZW50KTsKKworICAgIGlmIChhcmdzLkxlbmd0 aCgpICE9IDEpCisgICAgICAgIHJldHVybiB0aHJvd0Vycm9yKCJTaGFkb3dSb290IGNvbnN0cnVj dG9yIHJlcXVpcmVzIG9uZSBhcmd1bWVudCIsIFY4UHJveHk6OlJlZmVyZW5jZUVycm9yKTsKKwor ICAgIGlmICghVjhFbGVtZW50OjpIYXNJbnN0YW5jZShhcmdzWzBdKSkKKyAgICAgICAgcmV0dXJu IHRocm93RXJyb3IoIlNoYWRvd1Jvb3QgY29uc3RydWN0b3IgcmVxdWlyZXMgYW4gRWxlbWVudCBh cmd1bWVudCIsIFY4UHJveHk6OlR5cGVFcnJvcik7CisKKyAgICBSZWZQdHI8RWxlbWVudD4gZWxl bWVudCA9IFY4RWxlbWVudDo6dG9OYXRpdmUodjg6OkxvY2FsPHY4OjpPYmplY3Q+KHY4OjpPYmpl Y3Q6OkNhc3QoKmFyZ3NbMF0pKSk7CisgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CisgICAgZWxl bWVudC0+c2V0U2hhZG93Um9vdChTaGFkb3dSb290OjpjcmVhdGUoZG9jdW1lbnQpLCBlYyk7Cisg ICAgaWYgKGVjKSB7CisgICAgICAgIFY4UHJveHk6OnNldERPTUV4Y2VwdGlvbihlYyk7CisgICAg ICAgIHJldHVybiB2ODo6SGFuZGxlPHY4OjpWYWx1ZT4oKTsKKyAgICB9CisgICAgUmVmUHRyPFNo YWRvd1Jvb3Q+IHNoYWRvd1Jvb3QgPSBlbGVtZW50LT5zaGFkb3dSb290KCk7CisgICAgVjhET01X cmFwcGVyOjpzZXRET01XcmFwcGVyKGFyZ3MuSG9sZGVyKCksICZWOFNoYWRvd1Jvb3RDb25zdHJ1 Y3Rvcjo6aW5mbywgc2hhZG93Um9vdC5nZXQoKSk7CisgICAgc2hhZG93Um9vdC0+cmVmKCk7Cisg ICAgVjhET01XcmFwcGVyOjpzZXRKU1dyYXBwZXJGb3JET01Ob2RlKHNoYWRvd1Jvb3QuZ2V0KCks IHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+OjpOZXcoYXJncy5Ib2xkZXIoKSkpOworICAgIHJl dHVybiBhcmdzLkhvbGRlcigpOworfQorCit2ODo6UGVyc2lzdGVudDx2ODo6RnVuY3Rpb25UZW1w bGF0ZT4gVjhTaGFkb3dSb290Q29uc3RydWN0b3I6OkdldFRlbXBsYXRlKCkKK3sKKyAgICBzdGF0 aWMgdjg6OlBlcnNpc3RlbnQ8djg6OkZ1bmN0aW9uVGVtcGxhdGU+IGNhY2hlZFRlbXBsYXRlOwor ICAgIGlmICghY2FjaGVkVGVtcGxhdGUuSXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gY2FjaGVk VGVtcGxhdGU7CisKKyAgICB2ODo6SGFuZGxlU2NvcGUgc2NvcGU7CisgICAgdjg6OkxvY2FsPHY4 OjpGdW5jdGlvblRlbXBsYXRlPiByZXN1bHQgPSB2ODo6RnVuY3Rpb25UZW1wbGF0ZTo6TmV3KHY4 U2hhZG93Um9vdENvbnN0cnVjdG9yQ2FsbGJhY2spOworCisgICAgdjg6OkxvY2FsPHY4OjpPYmpl Y3RUZW1wbGF0ZT4gaW5zdGFuY2UgPSByZXN1bHQtPkluc3RhbmNlVGVtcGxhdGUoKTsKKyAgICBp bnN0YW5jZS0+U2V0SW50ZXJuYWxGaWVsZENvdW50KFY4U2hhZG93Um9vdDo6aW50ZXJuYWxGaWVs ZENvdW50KTsKKyAgICByZXN1bHQtPlNldENsYXNzTmFtZSh2ODo6U3RyaW5nOjpOZXcoIlNoYWRv d1Jvb3QiKSk7CisgICAgcmVzdWx0LT5Jbmhlcml0KFY4U2hhZG93Um9vdDo6R2V0VGVtcGxhdGUo KSk7CisKKyAgICBjYWNoZWRUZW1wbGF0ZSA9IHY4OjpQZXJzaXN0ZW50PHY4OjpGdW5jdGlvblRl bXBsYXRlPjo6TmV3KHJlc3VsdCk7CisgICAgcmV0dXJuIGNhY2hlZFRlbXBsYXRlOworfQorCit9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5n cy92OC9jdXN0b20vVjhTaGFkb3dSb290Q29uc3RydWN0b3IuaCBiL1NvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL3Y4L2N1c3RvbS9WOFNoYWRvd1Jvb3RDb25zdHJ1Y3Rvci5oCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZk YWZmNmNhMDlhZTEyYmY3ZjMzZGJlMDAwZTVlMmVmNTNlMTM2MmYKLS0tIC9kZXYvbnVsbAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhTaGFkb3dSb290Q29uc3RydWN0 b3IuaApAQCAtMCwwICsxLDQzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIEdvb2dsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMi IEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UgT0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBWOFNoYWRvd1Jvb3RDb25zdHJ1 Y3Rvcl9oCisjZGVmaW5lIFY4U2hhZG93Um9vdENvbnN0cnVjdG9yX2gKKworI2luY2x1ZGUgIldy YXBwZXJUeXBlSW5mby5oIgorCisjaW5jbHVkZSA8djguaD4KKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitjbGFzcyBWOFNoYWRvd1Jvb3RDb25zdHJ1Y3RvciB7CitwdWJsaWM6CisgICAgc3RhdGlj IHY4OjpQZXJzaXN0ZW50PHY4OjpGdW5jdGlvblRlbXBsYXRlPiBHZXRUZW1wbGF0ZSgpOworICAg IHN0YXRpYyBXcmFwcGVyVHlwZUluZm8gaW5mbzsKK307CisKK30KKworI2VuZGlmCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9k b20vU2hhZG93Um9vdC5pZGwKaW5kZXggOWE4MDkzMzU4YmRjMGZmZjAxYzg2OTczNWUwYTQzZmQy MzAzYTEzYy4uMWRmNWUxOTFmOTM1ZmFiZWZkNGQyZmYxNmIyNTM4MzBlYjY1MmM4MCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuaWRsCisrKyBiL1NvdXJjZS9XZWJD b3JlL2RvbS9TaGFkb3dSb290LmlkbApAQCAtMjgsNyArMjgsOCBAQCBtb2R1bGUgY29yZSB7CiAK ICAgICBpbnRlcmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1TSEFET1dfRE9NLAotICAgICAg ICBFbmFibGVkQXRSdW50aW1lPXNoYWRvd0RPTQorICAgICAgICBFbmFibGVkQXRSdW50aW1lPXNo YWRvd0RPTSwKKyAgICAgICAgQ3VzdG9tQ29uc3RydWN0RnVuY3Rpb24KICAgICBdIFNoYWRvd1Jv b3QgOiBOb2RlIHsKICAgICAgICAgcmVhZG9ubHkgYXR0cmlidXRlIEVsZW1lbnQgaG9zdDsKICAg ICB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsIGIvU291 cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsCmluZGV4IDE0MjI4ZDc3ZTYyNGJkMDYzOGI0 ZDQwMGNmNmM4MDQ2OGE1YWE1ZGMuLmRhNDViZWM3YjZlYWEyYTFhZTMzMGM4MDdlZTE3NDc1YmQ2 NzhkNjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwKQEAgLTM5OCw2ICszOTgsNyBAQCBt b2R1bGUgd2luZG93IHsKICAgICAgICAgYXR0cmlidXRlIEVudGl0eUNvbnN0cnVjdG9yIEVudGl0 eTsKICAgICAgICAgYXR0cmlidXRlIEVudGl0eVJlZmVyZW5jZUNvbnN0cnVjdG9yIEVudGl0eVJl ZmVyZW5jZTsKICAgICAgICAgYXR0cmlidXRlIFByb2Nlc3NpbmdJbnN0cnVjdGlvbkNvbnN0cnVj dG9yIFByb2Nlc3NpbmdJbnN0cnVjdGlvbjsKKyAgICAgICAgYXR0cmlidXRlIFtDdXN0b21HZXR0 ZXIsIENvbmRpdGlvbmFsPVNIQURPV19ET01dIFNoYWRvd1Jvb3RDb25zdHJ1Y3RvciBTaGFkb3dS b290CiAKICAgICAgICAgYXR0cmlidXRlIEhUTUxEb2N1bWVudENvbnN0cnVjdG9yIEhUTUxEb2N1 bWVudDsKIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCmluZGV4IDRlNGIzNTU0YzNkODNlY2VlZjdhMTAwMDVhZWM1MmFmYWMzYmYwN2Eu LjY2MTQyYjFlODE4MjY2NDhhYzA5ZDJkZDJjZjE0Yjk3MjA3NTJjOTMgMTAwNjQ0Ci0tLSBhL0xh eW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxMiBAQAorMjAxMi0wMS0yMyAgSGF5YXRvIEl0byAgPGhheWF0b0BjaHJvbWl1bS5vcmc+CisK KyAgICAgICAgQWRkIGEgU2hhZG93Um9vdCBjb25zdHJ1Y3Rvciwgd2hpY2ggaXMgZW5hYmxlZCBi eSBTSEFET1dfRE9NIGZsYWcuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD03NjM1NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpzLWFwaS5odG1sOgorCiAy MDEyLTAxLTIyICBOaWtvbGFzIFppbW1lcm1hbm4gIDxuemltbWVybWFubkByaW0uY29tPgogCiAg ICAgICAgIE5vdCByZXZpZXdlZC4gRml4IHR5cG8sIHdoaWNoIG1ha2VzIHRoZSBzdHlsZSBib3Qg d2FybiBvbiBldmVyeSBwYXRjaC4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL3No YWRvdy9zaGFkb3ctcm9vdC1qcy1hcGkuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NoYWRv dy9zaGFkb3ctcm9vdC1qcy1hcGkuaHRtbAppbmRleCBjZDZjNDQ2ZjJhODhmMDU2YWZmZmU0MDU0 ODI5ZDExYzJmNDQ3YzQ5Li5jYjFlY2Q5MTZkYWU2NzUyYWMxZDc0ZGM5NmY0MjIyYTkxYzg2ODg1 IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJvb3QtanMt YXBpLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpz LWFwaS5odG1sCkBAIC0xMSw4ICsxMSw3IEBAIGRlc2NyaXB0aW9uKCJUZXN0cyBmb3IgU2hhZG93 Um9vdCBKUyBBUElzLiBDYW4gb25seSBydW4gd2l0aGluIERSVCIpOwogaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikKICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7 CiB2YXIgc2hhZG93SG9zdCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpOwotaW50ZXJu YWxzLmVuc3VyZVNoYWRvd1Jvb3Qoc2hhZG93SG9zdCk7Ci12YXIgc2hhZG93Um9vdCA9IGludGVy bmFscy5zaGFkb3dSb290KHNoYWRvd0hvc3QpOwordmFyIHNoYWRvd1Jvb3QgPSBuZXcgU2hhZG93 Um9vdChzaGFkb3dIb3N0KTsKIHNob3VsZEJlKCJzaGFkb3dIb3N0IiwgInNoYWRvd1Jvb3QuaG9z dCIpOwogCiA8L3NjcmlwdD4K 123892 2012-01-24 23:42:12 -0800 2012-01-25 04:21:47 -0800 Add ShadowRoot consturctor as WebKitShadowRoot bug-76354-20120125164211.patch text/plain 5186 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1ODMyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNmMwYjE1MGI0OWRjMjA0 MzMzZmUzOGFiZjVkY2U2MzNkZjY1YjQ2My4uYjJkZGYzN2E3N2YxOTYwZWQ0OThhYTA3NzZkOGRm OGZmMTZkODkwZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEyLTAxLTIzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgYSBTaGFkb3dSb290 IGNvbnN0cnVjdG9yIGFzICdXZWJLaXRTaGFkb3dSb290Q29uc3RydWN0b3InLCBlbmFibGVkIGJ5 IFNIQURPV19ET00gZmxhZy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTc2MzU0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgV2UgdXNlIHZlbmRvci1wcmVmaXhlZCBuYW1lLCAnV2ViS2l0U2hhZG93Um9vdCcs IGluc3RlYWQgb2YgJ1NoYWRvd1Jvb3QnCisgICAgICAgIHNpbmNlIHRoaXMgaXMgYSBmZWF0dXJl IHVuZGVyIGRldmVsb3BtZW50LgorCisgICAgICAgICogZG9tL1NoYWRvd1Jvb3QuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6U2hhZG93Um9vdDo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAqIGRvbS9TaGFkb3dSb290Lmg6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAg KFNoYWRvd1Jvb3QpOgorICAgICAgICAqIGRvbS9TaGFkb3dSb290LmlkbDoKKyAgICAgICAgKiBw YWdlL0RPTVdpbmRvdy5pZGw6CisKIDIwMTItMDEtMjQgIEtlbiBCdWNoYW5hbiAgPGtlbnJiQGNo cm9taXVtLm9yZz4KIAogICAgICAgICBDcmFzaCBpbiB1cGRhdGVGaXJzdExldHRlcigpIGZyb20g dW5uZWNlc3NhcnkgYW5vbnltb3VzIGJsb2NrCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9k b20vU2hhZG93Um9vdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5jcHAKaW5k ZXggMjI5ZDU1ODE1YTdmYWVlZTQ3OGFkMjlhNzA4YjI1ODk2YjI0ZWE2Yy4uYzAyNGUxZWMyZDNi MmIyN2Y5MWM5OGMwZWM4MTQyZTAyOGJhMjA5NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv ZG9tL1NoYWRvd1Jvb3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290LmNw cApAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgIkNvbnRlbnRJbmNsdXNpb25TZWxlY3Rvci5o IgogI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRWxlbWVudC5oIgorI2luY2x1ZGUg IkV4Y2VwdGlvbkNvZGUuaCIKICNpbmNsdWRlICJIVE1MQ29udGVudEVsZW1lbnQuaCIKICNpbmNs dWRlICJOb2RlUmFyZURhdGEuaCIKICNpbmNsdWRlICJUZXh0LmgiCkBAIC01Myw2ICs1NCwxNiBA QCBTaGFkb3dSb290Ojp+U2hhZG93Um9vdCgpCiB7CiB9CiAKK1Bhc3NSZWZQdHI8U2hhZG93Um9v dD4gU2hhZG93Um9vdDo6Y3JlYXRlKEVsZW1lbnQqIGVsZW1lbnQpCit7CisgICAgQVNTRVJUKGVs ZW1lbnQpOworICAgIFJlZlB0cjxTaGFkb3dSb290PiBzaGFkb3dSb290ID0gY3JlYXRlKGVsZW1l bnQtPmRvY3VtZW50KCkpOworICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgIGVsZW1lbnQt PnNldFNoYWRvd1Jvb3Qoc2hhZG93Um9vdCwgZWMpOworICAgIEFTU0VSVCghZWMpOworICAgIHJl dHVybiBzaGFkb3dSb290LnJlbGVhc2UoKTsKK30KKwogU3RyaW5nIFNoYWRvd1Jvb3Q6Om5vZGVO YW1lKCkgY29uc3QKIHsKICAgICByZXR1cm4gIiNzaGFkb3ctcm9vdCI7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5oIGIvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRv d1Jvb3QuaAppbmRleCBkYWU4OTVjYTczNzI2ZDRkNGNjYTk5ODQ3YjkwOWUwMWQ3ODU4M2U4Li5m NTdmZWFjYjU1NWMyYjRmMDIxZWM5MDMyZTQ5ZGVlMTM1OTY5ZGEyIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFk b3dSb290LmgKQEAgLTMxLDEzICszMSwxNSBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2Ns YXNzIENvbnRlbnRJbmNsdXNpb25TZWxlY3RvcjsKIGNsYXNzIERvY3VtZW50OwogY2xhc3MgSFRN TENvbnRlbnRFbGVtZW50OwotY2xhc3MgQ29udGVudEluY2x1c2lvblNlbGVjdG9yOworY2xhc3Mg U2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAogY2xhc3MgU2hhZG93Um9vdCA6IHB1YmxpYyBUcmVl U2NvcGUgewogcHVibGljOgogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNoYWRvd1Jvb3Q+IGNyZWF0 ZShEb2N1bWVudCopOworICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNoYWRvd1Jvb3Q+IGNyZWF0ZShF bGVtZW50Kik7CiAKICAgICB2b2lkIHJlY2FsY1NoYWRvd1RyZWVTdHlsZShTdHlsZUNoYW5nZSk7 CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290LmlkbCBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290LmlkbAppbmRleCA5YTgwOTMzNThiZGMwZmZmMDFjODY5 NzM1ZTBhNDNmZDIzMDNhMTNjLi41ZWVjNTBjNThiZDllOTJkZjM0NjU2ZmZkZjgxMTQ5YzExOGMw NDBjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5pZGwKKysrIGIv U291cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuaWRsCkBAIC0yOCw3ICsyOCw4IEBAIG1vZHVs ZSBjb3JlIHsKIAogICAgIGludGVyZmFjZSBbCiAgICAgICAgIENvbmRpdGlvbmFsPVNIQURPV19E T00sCi0gICAgICAgIEVuYWJsZWRBdFJ1bnRpbWU9c2hhZG93RE9NCisgICAgICAgIEVuYWJsZWRB dFJ1bnRpbWU9c2hhZG93RE9NLAorICAgICAgICBDb25zdHJ1Y3RvcihpbiBFbGVtZW50IGhvc3Qp CiAgICAgXSBTaGFkb3dSb290IDogTm9kZSB7CiAgICAgICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSBF bGVtZW50IGhvc3Q7CiAgICAgfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRE9N V2luZG93LmlkbCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbAppbmRleCA5OWUy YmM0MDI3M2FmZDFhODA0ODdlNTNkYzRlOWMyOTZmOTY3NGJiLi45NzRiODRkYWM4NzQzM2U0MTI3 YjMwODFkZTBmNTAxMGNhNWM2Zjc4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0RP TVdpbmRvdy5pZGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsCkBAIC0z OTgsNiArMzk4LDcgQEAgbW9kdWxlIHdpbmRvdyB7CiAgICAgICAgIGF0dHJpYnV0ZSBFbnRpdHlD b25zdHJ1Y3RvciBFbnRpdHk7CiAgICAgICAgIGF0dHJpYnV0ZSBFbnRpdHlSZWZlcmVuY2VDb25z dHJ1Y3RvciBFbnRpdHlSZWZlcmVuY2U7CiAgICAgICAgIGF0dHJpYnV0ZSBQcm9jZXNzaW5nSW5z dHJ1Y3Rpb25Db25zdHJ1Y3RvciBQcm9jZXNzaW5nSW5zdHJ1Y3Rpb247CisgICAgICAgIGF0dHJp YnV0ZSBbQ29uZGl0aW9uYWw9U0hBRE9XX0RPTSwgRW5hYmxlZEF0UnVudGltZT1zaGFkb3dET01d IFNoYWRvd1Jvb3RDb25zdHJ1Y3RvciBXZWJLaXRTaGFkb3dSb290OwogCiAgICAgICAgIGF0dHJp YnV0ZSBIVE1MRG9jdW1lbnRDb25zdHJ1Y3RvciBIVE1MRG9jdW1lbnQ7CiAKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA4NGMz NDIzMGE1MmU4ZGFhOGRjOTgzMDE2YmI4MDRlZGExNDk0MWM5Li42Y2ExYjExMDI4NmEzNDlmMzU0 OWI0YjcxNjBlZDBlMzk0MzEyYTE4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cK KysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTItMDEtMjQg IEhheWF0byBJdG8gIDxoYXlhdG9AY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBhIFNoYWRv d1Jvb3QgY29uc3RydWN0b3IgYXMgJ1dlYktpdFNoYWRvd1Jvb3RDb25zdHJ1Y3RvcicsIGVuYWJs ZWQgYnkgU0hBRE9XX0RPTSBmbGFnLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NzYzNTQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBXZSB1c2UgdmVuZG9yLXByZWZpeGVkIG5hbWUsICdXZWJLaXRTaGFkb3dS b290JywgaW5zdGVhZCBvZiAnU2hhZG93Um9vdCcKKyAgICAgICAgc2luY2UgdGhpcyBpcyBhIGZl YXR1cmUgdW5kZXIgZGV2ZWxvcG1lbnQuCisKKyAgICAgICAgKiBmYXN0L2RvbS9zaGFkb3cvc2hh ZG93LXJvb3QtanMtYXBpLmh0bWw6CisKIDIwMTItMDEtMjQgIEFkYW0gQmFydGggIDxhYmFydGhA d2Via2l0Lm9yZz4KIAogICAgICAgICBBZGQgTGludXgtc3BlY2lmaWMgb3ZlcnJpZGVzLgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpzLWFwaS5o dG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpzLWFwaS5odG1s CmluZGV4IGNkNmM0NDZmMmE4OGYwNTZhZmZmZTQwNTQ4MjlkMTFjMmY0NDdjNDkuLjM2Y2ZmYTkx MGUzOGE4Yjg2MjkyNGMxZmQ2NmNiNzNiY2Y4MWE4ZGUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3Rz L2Zhc3QvZG9tL3NoYWRvdy9zaGFkb3ctcm9vdC1qcy1hcGkuaHRtbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJvb3QtanMtYXBpLmh0bWwKQEAgLTExLDggKzExLDcg QEAgZGVzY3JpcHRpb24oIlRlc3RzIGZvciBTaGFkb3dSb290IEpTIEFQSXMuIENhbiBvbmx5IHJ1 biB3aXRoaW4gRFJUIik7CiBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQogICAgIGxh eW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKIHZhciBzaGFkb3dIb3N0ID0gZG9jdW1l bnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7Ci1pbnRlcm5hbHMuZW5zdXJlU2hhZG93Um9vdChzaGFk b3dIb3N0KTsKLXZhciBzaGFkb3dSb290ID0gaW50ZXJuYWxzLnNoYWRvd1Jvb3Qoc2hhZG93SG9z dCk7Cit2YXIgc2hhZG93Um9vdCA9IG5ldyBXZWJLaXRTaGFkb3dSb290KHNoYWRvd0hvc3QpOwog c2hvdWxkQmUoInNoYWRvd0hvc3QiLCAic2hhZG93Um9vdC5ob3N0Iik7CiAKIDwvc2NyaXB0Pgo= 123919 2012-01-25 04:21:55 -0800 2012-01-25 04:54:18 -0800 Use ExceptionCode bug-76354-20120125212154.patch text/plain 5105 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1ODMyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNmMwYjE1MGI0OWRjMjA0 MzMzZmUzOGFiZjVkY2U2MzNkZjY1YjQ2My4uOTE3ZDg3OGViYmMyOThhYzM4ZTg5MjE3MTQyNjVi MWM5ODQ1NDU1MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEyLTAxLTIzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgYSBTaGFkb3dSb290 IGNvbnN0cnVjdG9yIGFzICdXZWJLaXRTaGFkb3dSb290Q29uc3RydWN0b3InLCBlbmFibGVkIGJ5 IFNIQURPV19ET00gZmxhZy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTc2MzU0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgV2UgdXNlIHZlbmRvci1wcmVmaXhlZCBuYW1lLCAnV2ViS2l0U2hhZG93Um9vdCcs IGluc3RlYWQgb2YgJ1NoYWRvd1Jvb3QnCisgICAgICAgIHNpbmNlIHRoaXMgaXMgYW4gdW5kZXIg ZGV2ZWxvcG1lbnQgZmVhdHVyZS4KKworICAgICAgICAqIGRvbS9TaGFkb3dSb290LmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlNoYWRvd1Jvb3Q6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlKToK KyAgICAgICAgKiBkb20vU2hhZG93Um9vdC5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAg IChTaGFkb3dSb290KToKKyAgICAgICAgKiBkb20vU2hhZG93Um9vdC5pZGw6CisgICAgICAgICog cGFnZS9ET01XaW5kb3cuaWRsOgorCiAyMDEyLTAxLTI0ICBLZW4gQnVjaGFuYW4gIDxrZW5yYkBj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgQ3Jhc2ggaW4gdXBkYXRlRmlyc3RMZXR0ZXIoKSBmcm9t IHVubmVjZXNzYXJ5IGFub255bW91cyBibG9jawpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv ZG9tL1NoYWRvd1Jvb3QuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuY3BwCmlu ZGV4IDIyOWQ1NTgxNWE3ZmFlZWU0NzhhZDI5YTcwOGIyNTg5NmIyNGVhNmMuLjJkNTM1Njk1YTc4 MDdmMTk5OWZkMjk1YzVjYjYxZDFkMjBkZmZhZDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2RvbS9TaGFkb3dSb290LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5j cHAKQEAgLTUzLDYgKzUzLDE2IEBAIFNoYWRvd1Jvb3Q6On5TaGFkb3dSb290KCkKIHsKIH0KIAor UGFzc1JlZlB0cjxTaGFkb3dSb290PiBTaGFkb3dSb290OjpjcmVhdGUoRWxlbWVudCogZWxlbWVu dCwgRXhjZXB0aW9uQ29kZSYgZWMpCit7CisgICAgQVNTRVJUKGVsZW1lbnQpOworICAgIFJlZlB0 cjxTaGFkb3dSb290PiBzaGFkb3dSb290ID0gY3JlYXRlKGVsZW1lbnQtPmRvY3VtZW50KCkpOwor ICAgIGVsZW1lbnQtPnNldFNoYWRvd1Jvb3Qoc2hhZG93Um9vdCwgZWMpOworICAgIGlmIChlYykK KyAgICAgICAgcmV0dXJuIDA7CisgICAgcmV0dXJuIHNoYWRvd1Jvb3QucmVsZWFzZSgpOworfQor CiBTdHJpbmcgU2hhZG93Um9vdDo6bm9kZU5hbWUoKSBjb25zdAogewogICAgIHJldHVybiAiI3No YWRvdy1yb290IjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290Lmgg Yi9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5oCmluZGV4IGRhZTg5NWNhNzM3MjZkNGQ0 Y2NhOTk4NDdiOTA5ZTAxZDc4NTgzZTguLjgzNmU0YWFhY2Q0ZjZjZTE1ZjdjYWVjYmI4YmZiNzY2 NDdiZmNkN2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290LmgKKysr IGIvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuaApAQCAtMjcsMTcgKzI3LDE5IEBACiAj aWZuZGVmIFNoYWRvd1Jvb3RfaAogI2RlZmluZSBTaGFkb3dSb290X2gKIAorI2luY2x1ZGUgIkV4 Y2VwdGlvbkNvZGUuaCIKICNpbmNsdWRlICJUcmVlU2NvcGUuaCIKIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCitjbGFzcyBDb250ZW50SW5jbHVzaW9uU2VsZWN0b3I7CiBjbGFzcyBEb2N1bWVudDsK IGNsYXNzIEhUTUxDb250ZW50RWxlbWVudDsKLWNsYXNzIENvbnRlbnRJbmNsdXNpb25TZWxlY3Rv cjsKIAogY2xhc3MgU2hhZG93Um9vdCA6IHB1YmxpYyBUcmVlU2NvcGUgewogcHVibGljOgogICAg IHN0YXRpYyBQYXNzUmVmUHRyPFNoYWRvd1Jvb3Q+IGNyZWF0ZShEb2N1bWVudCopOworICAgIHN0 YXRpYyBQYXNzUmVmUHRyPFNoYWRvd1Jvb3Q+IGNyZWF0ZShFbGVtZW50KiwgRXhjZXB0aW9uQ29k ZSYpOwogCiAgICAgdm9pZCByZWNhbGNTaGFkb3dUcmVlU3R5bGUoU3R5bGVDaGFuZ2UpOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5pZGwgYi9Tb3VyY2UvV2Vi Q29yZS9kb20vU2hhZG93Um9vdC5pZGwKaW5kZXggOWE4MDkzMzU4YmRjMGZmZjAxYzg2OTczNWUw YTQzZmQyMzAzYTEzYy4uYmJjY2U5OGFjM2QyY2QwZTRjZGUwNjQ2ODhmNGZlYTY2ZmRhMTBiOCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuaWRsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290LmlkbApAQCAtMjgsNyArMjgsOSBAQCBtb2R1bGUgY29y ZSB7CiAKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1TSEFET1dfRE9NLAot ICAgICAgICBFbmFibGVkQXRSdW50aW1lPXNoYWRvd0RPTQorICAgICAgICBFbmFibGVkQXRSdW50 aW1lPXNoYWRvd0RPTSwKKyAgICAgICAgQ29uc3RydWN0b3IoaW4gRWxlbWVudCBob3N0KSwKKyAg ICAgICAgQ29uc3RydWN0b3JSYWlzZXNFeGNlcHRpb24KICAgICBdIFNoYWRvd1Jvb3QgOiBOb2Rl IHsKICAgICAgICAgcmVhZG9ubHkgYXR0cmlidXRlIEVsZW1lbnQgaG9zdDsKICAgICB9OwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsIGIvU291cmNlL1dlYkNv cmUvcGFnZS9ET01XaW5kb3cuaWRsCmluZGV4IDk5ZTJiYzQwMjczYWZkMWE4MDQ4N2U1M2RjNGU5 YzI5NmY5Njc0YmIuLjk3NGI4NGRhYzg3NDMzZTQxMjdiMzA4MWRlMGY1MDEwY2E1YzZmNzggMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwKQEAgLTM5OCw2ICszOTgsNyBAQCBtb2R1bGUgd2lu ZG93IHsKICAgICAgICAgYXR0cmlidXRlIEVudGl0eUNvbnN0cnVjdG9yIEVudGl0eTsKICAgICAg ICAgYXR0cmlidXRlIEVudGl0eVJlZmVyZW5jZUNvbnN0cnVjdG9yIEVudGl0eVJlZmVyZW5jZTsK ICAgICAgICAgYXR0cmlidXRlIFByb2Nlc3NpbmdJbnN0cnVjdGlvbkNvbnN0cnVjdG9yIFByb2Nl c3NpbmdJbnN0cnVjdGlvbjsKKyAgICAgICAgYXR0cmlidXRlIFtDb25kaXRpb25hbD1TSEFET1df RE9NLCBFbmFibGVkQXRSdW50aW1lPXNoYWRvd0RPTV0gU2hhZG93Um9vdENvbnN0cnVjdG9yIFdl YktpdFNoYWRvd1Jvb3Q7CiAKICAgICAgICAgYXR0cmlidXRlIEhUTUxEb2N1bWVudENvbnN0cnVj dG9yIEhUTUxEb2N1bWVudDsKIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDg0YzM0MjMwYTUyZThkYWE4ZGM5ODMwMTZiYjgw NGVkYTE0OTQxYzkuLjM2ZTY3YTJkMzcxMGY4NmVkMmVlM2VjNGUyZDNkOWM4YzA1MzRiMmIgMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMi0wMS0yNCAgSGF5YXRvIEl0byAgPGhheWF0b0BjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgQWRkIGEgU2hhZG93Um9vdCBjb25zdHJ1Y3RvciBhcyAnV2Vi S2l0U2hhZG93Um9vdENvbnN0cnVjdG9yJywgZW5hYmxlZCBieSBTSEFET1dfRE9NIGZsYWcuCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NjM1NAorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdlIHVzZSB2ZW5k b3ItcHJlZml4ZWQgbmFtZSwgJ1dlYktpdFNoYWRvd1Jvb3QnLCBpbnN0ZWFkIG9mICdTaGFkb3dS b290JworICAgICAgICBzaW5jZSB0aGlzIGlzIGFuIHVuZGVyIGRldmVsb3BtZW50IGZlYXR1cmUu CisKKyAgICAgICAgKiBmYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJvb3QtanMtYXBpLmh0bWw6CisK IDIwMTItMDEtMjQgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4KIAogICAgICAgICBB ZGQgTGludXgtc3BlY2lmaWMgb3ZlcnJpZGVzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpzLWFwaS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9k b20vc2hhZG93L3NoYWRvdy1yb290LWpzLWFwaS5odG1sCmluZGV4IGNkNmM0NDZmMmE4OGYwNTZh ZmZmZTQwNTQ4MjlkMTFjMmY0NDdjNDkuLjM2Y2ZmYTkxMGUzOGE4Yjg2MjkyNGMxZmQ2NmNiNzNi Y2Y4MWE4ZGUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NoYWRvdy9zaGFkb3ct cm9vdC1qcy1hcGkuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93 LXJvb3QtanMtYXBpLmh0bWwKQEAgLTExLDggKzExLDcgQEAgZGVzY3JpcHRpb24oIlRlc3RzIGZv ciBTaGFkb3dSb290IEpTIEFQSXMuIENhbiBvbmx5IHJ1biB3aXRoaW4gRFJUIik7CiBpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKQogICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBB c1RleHQoKTsKIHZhciBzaGFkb3dIb3N0ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7 Ci1pbnRlcm5hbHMuZW5zdXJlU2hhZG93Um9vdChzaGFkb3dIb3N0KTsKLXZhciBzaGFkb3dSb290 ID0gaW50ZXJuYWxzLnNoYWRvd1Jvb3Qoc2hhZG93SG9zdCk7Cit2YXIgc2hhZG93Um9vdCA9IG5l dyBXZWJLaXRTaGFkb3dSb290KHNoYWRvd0hvc3QpOwogc2hvdWxkQmUoInNoYWRvd0hvc3QiLCAi c2hhZG93Um9vdC5ob3N0Iik7CiAKIDwvc2NyaXB0Pgo= 123924 2012-01-25 04:54:26 -0800 2012-01-25 20:57:04 -0800 Validate input Element bug-76354-20120125215425.patch text/plain 6276 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1ODMyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNmMwYjE1MGI0OWRjMjA0 MzMzZmUzOGFiZjVkY2U2MzNkZjY1YjQ2My4uOTE3ZDg3OGViYmMyOThhYzM4ZTg5MjE3MTQyNjVi MWM5ODQ1NDU1MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEyLTAxLTIzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgYSBTaGFkb3dSb290 IGNvbnN0cnVjdG9yIGFzICdXZWJLaXRTaGFkb3dSb290Q29uc3RydWN0b3InLCBlbmFibGVkIGJ5 IFNIQURPV19ET00gZmxhZy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTc2MzU0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgV2UgdXNlIHZlbmRvci1wcmVmaXhlZCBuYW1lLCAnV2ViS2l0U2hhZG93Um9vdCcs IGluc3RlYWQgb2YgJ1NoYWRvd1Jvb3QnCisgICAgICAgIHNpbmNlIHRoaXMgaXMgYW4gdW5kZXIg ZGV2ZWxvcG1lbnQgZmVhdHVyZS4KKworICAgICAgICAqIGRvbS9TaGFkb3dSb290LmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlNoYWRvd1Jvb3Q6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlKToK KyAgICAgICAgKiBkb20vU2hhZG93Um9vdC5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAg IChTaGFkb3dSb290KToKKyAgICAgICAgKiBkb20vU2hhZG93Um9vdC5pZGw6CisgICAgICAgICog cGFnZS9ET01XaW5kb3cuaWRsOgorCiAyMDEyLTAxLTI0ICBLZW4gQnVjaGFuYW4gIDxrZW5yYkBj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgQ3Jhc2ggaW4gdXBkYXRlRmlyc3RMZXR0ZXIoKSBmcm9t IHVubmVjZXNzYXJ5IGFub255bW91cyBibG9jawpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv ZG9tL1NoYWRvd1Jvb3QuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuY3BwCmlu ZGV4IDIyOWQ1NTgxNWE3ZmFlZWU0NzhhZDI5YTcwOGIyNTg5NmIyNGVhNmMuLjYzOGNlMjdlNDE1 N2ViOWU4Y2NlMjRmOGVmMTZmYTlhZmMzNTU1MDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2RvbS9TaGFkb3dSb290LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5j cHAKQEAgLTUzLDYgKzUzLDIzIEBAIFNoYWRvd1Jvb3Q6On5TaGFkb3dSb290KCkKIHsKIH0KIAor UGFzc1JlZlB0cjxTaGFkb3dSb290PiBTaGFkb3dSb290OjpjcmVhdGUoRWxlbWVudCogZWxlbWVu dCwgRXhjZXB0aW9uQ29kZSYgZWMpCit7CisgICAgaWYgKCFlbGVtZW50IHx8ICFlbGVtZW50LT5p c0VsZW1lbnROb2RlKCkpIHsKKyAgICAgICAgZWMgPSBUWVBFX01JU01BVENIX0VSUjsKKyAgICAg ICAgcmV0dXJuIDA7CisgICAgfQorICAgIGlmICghZWxlbWVudC0+ZG9jdW1lbnQoKSkgeworICAg ICAgICBlYyA9IFdST05HX0RPQ1VNRU5UX0VSUjsKKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQor ICAgIFJlZlB0cjxTaGFkb3dSb290PiBzaGFkb3dSb290ID0gY3JlYXRlKGVsZW1lbnQtPmRvY3Vt ZW50KCkpOworICAgIGVsZW1lbnQtPnNldFNoYWRvd1Jvb3Qoc2hhZG93Um9vdCwgZWMpOworICAg IGlmIChlYykKKyAgICAgICAgcmV0dXJuIDA7CisgICAgcmV0dXJuIHNoYWRvd1Jvb3QucmVsZWFz ZSgpOworfQorCiBTdHJpbmcgU2hhZG93Um9vdDo6bm9kZU5hbWUoKSBjb25zdAogewogICAgIHJl dHVybiAiI3NoYWRvdy1yb290IjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFk b3dSb290LmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5oCmluZGV4IGRhZTg5NWNh NzM3MjZkNGQ0Y2NhOTk4NDdiOTA5ZTAxZDc4NTgzZTguLjgzNmU0YWFhY2Q0ZjZjZTE1ZjdjYWVj YmI4YmZiNzY2NDdiZmNkN2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dS b290LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuaApAQCAtMjcsMTcgKzI3 LDE5IEBACiAjaWZuZGVmIFNoYWRvd1Jvb3RfaAogI2RlZmluZSBTaGFkb3dSb290X2gKIAorI2lu Y2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKICNpbmNsdWRlICJUcmVlU2NvcGUuaCIKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCitjbGFzcyBDb250ZW50SW5jbHVzaW9uU2VsZWN0b3I7CiBjbGFzcyBE b2N1bWVudDsKIGNsYXNzIEhUTUxDb250ZW50RWxlbWVudDsKLWNsYXNzIENvbnRlbnRJbmNsdXNp b25TZWxlY3RvcjsKIAogY2xhc3MgU2hhZG93Um9vdCA6IHB1YmxpYyBUcmVlU2NvcGUgewogcHVi bGljOgogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNoYWRvd1Jvb3Q+IGNyZWF0ZShEb2N1bWVudCop OworICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNoYWRvd1Jvb3Q+IGNyZWF0ZShFbGVtZW50KiwgRXhj ZXB0aW9uQ29kZSYpOwogCiAgICAgdm9pZCByZWNhbGNTaGFkb3dUcmVlU3R5bGUoU3R5bGVDaGFu Z2UpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5pZGwgYi9T b3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5pZGwKaW5kZXggOWE4MDkzMzU4YmRjMGZmZjAx Yzg2OTczNWUwYTQzZmQyMzAzYTEzYy4uYmJjY2U5OGFjM2QyY2QwZTRjZGUwNjQ2ODhmNGZlYTY2 ZmRhMTBiOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuaWRsCisr KyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290LmlkbApAQCAtMjgsNyArMjgsOSBAQCBt b2R1bGUgY29yZSB7CiAKICAgICBpbnRlcmZhY2UgWwogICAgICAgICBDb25kaXRpb25hbD1TSEFE T1dfRE9NLAotICAgICAgICBFbmFibGVkQXRSdW50aW1lPXNoYWRvd0RPTQorICAgICAgICBFbmFi bGVkQXRSdW50aW1lPXNoYWRvd0RPTSwKKyAgICAgICAgQ29uc3RydWN0b3IoaW4gRWxlbWVudCBo b3N0KSwKKyAgICAgICAgQ29uc3RydWN0b3JSYWlzZXNFeGNlcHRpb24KICAgICBdIFNoYWRvd1Jv b3QgOiBOb2RlIHsKICAgICAgICAgcmVhZG9ubHkgYXR0cmlidXRlIEVsZW1lbnQgaG9zdDsKICAg ICB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsIGIvU291 cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsCmluZGV4IDk5ZTJiYzQwMjczYWZkMWE4MDQ4 N2U1M2RjNGU5YzI5NmY5Njc0YmIuLjk3NGI4NGRhYzg3NDMzZTQxMjdiMzA4MWRlMGY1MDEwY2E1 YzZmNzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwKQEAgLTM5OCw2ICszOTgsNyBAQCBt b2R1bGUgd2luZG93IHsKICAgICAgICAgYXR0cmlidXRlIEVudGl0eUNvbnN0cnVjdG9yIEVudGl0 eTsKICAgICAgICAgYXR0cmlidXRlIEVudGl0eVJlZmVyZW5jZUNvbnN0cnVjdG9yIEVudGl0eVJl ZmVyZW5jZTsKICAgICAgICAgYXR0cmlidXRlIFByb2Nlc3NpbmdJbnN0cnVjdGlvbkNvbnN0cnVj dG9yIFByb2Nlc3NpbmdJbnN0cnVjdGlvbjsKKyAgICAgICAgYXR0cmlidXRlIFtDb25kaXRpb25h bD1TSEFET1dfRE9NLCBFbmFibGVkQXRSdW50aW1lPXNoYWRvd0RPTV0gU2hhZG93Um9vdENvbnN0 cnVjdG9yIFdlYktpdFNoYWRvd1Jvb3Q7CiAKICAgICAgICAgYXR0cmlidXRlIEhUTUxEb2N1bWVu dENvbnN0cnVjdG9yIEhUTUxEb2N1bWVudDsKIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDg0YzM0MjMwYTUyZThkYWE4ZGM5 ODMwMTZiYjgwNGVkYTE0OTQxYzkuLjM2ZTY3YTJkMzcxMGY4NmVkMmVlM2VjNGUyZDNkOWM4YzA1 MzRiMmIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMi0wMS0yNCAgSGF5YXRvIEl0byAgPGhh eWF0b0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIGEgU2hhZG93Um9vdCBjb25zdHJ1Y3Rv ciBhcyAnV2ViS2l0U2hhZG93Um9vdENvbnN0cnVjdG9yJywgZW5hYmxlZCBieSBTSEFET1dfRE9N IGZsYWcuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03 NjM1NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdl IHVzZSB2ZW5kb3ItcHJlZml4ZWQgbmFtZSwgJ1dlYktpdFNoYWRvd1Jvb3QnLCBpbnN0ZWFkIG9m ICdTaGFkb3dSb290JworICAgICAgICBzaW5jZSB0aGlzIGlzIGFuIHVuZGVyIGRldmVsb3BtZW50 IGZlYXR1cmUuCisKKyAgICAgICAgKiBmYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJvb3QtanMtYXBp Lmh0bWw6CisKIDIwMTItMDEtMjQgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4KIAog ICAgICAgICBBZGQgTGludXgtc3BlY2lmaWMgb3ZlcnJpZGVzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpzLWFwaS1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJvb3QtanMtYXBpLWV4cGVjdGVkLnR4 dAppbmRleCAwZTA0Y2NjYWZjYjM2Y2UxYTlhYzc0MjQ5MmM4OGI5NDY1YzdmN2JjLi41Yzk5YjAz NTExMjhmNjQ4MzRhMzgzMjQzOTY5N2YzYjJiM2ZkODc4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJvb3QtanMtYXBpLWV4cGVjdGVkLnR4dAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJvb3QtanMtYXBpLWV4cGVjdGVkLnR4 dApAQCAtMyw2ICszLDkgQEAgVGVzdHMgZm9yIFNoYWRvd1Jvb3QgSlMgQVBJcy4gQ2FuIG9ubHkg cnVuIHdpdGhpbiBEUlQKIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFT UyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KIAogCitQQVNTIG5ldyBX ZWJLaXRTaGFkb3dSb290KCkgdGhyZXcgZXhjZXB0aW9uIFR5cGVFcnJvcjogTm90IGVub3VnaCBh cmd1bWVudHMuCitQQVNTIG5ldyBXZWJLaXRTaGFkb3dSb290KHVuZGVmaW5lZCkgdGhyZXcgZXhj ZXB0aW9uIEVycm9yOiBUWVBFX01JU01BVENIX0VSUjogRE9NIEV4Y2VwdGlvbiAxNy4KK1BBU1Mg bmV3IFdlYktpdFNoYWRvd1Jvb3QoMSkgdGhyZXcgZXhjZXB0aW9uIEVycm9yOiBUWVBFX01JU01B VENIX0VSUjogRE9NIEV4Y2VwdGlvbiAxNy4KIFBBU1Mgc2hhZG93SG9zdCBpcyBzaGFkb3dSb290 Lmhvc3QKIFBBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKIApkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpzLWFwaS5odG1sIGIvTGF5b3V0 VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpzLWFwaS5odG1sCmluZGV4IGNkNmM0 NDZmMmE4OGYwNTZhZmZmZTQwNTQ4MjlkMTFjMmY0NDdjNDkuLmJhYTgwMTJkNTBjNDYyN2E1YzU2 OGM4NTIxMzg2OGYxYzQzZmYyN2YgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL3No YWRvdy9zaGFkb3ctcm9vdC1qcy1hcGkuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9z aGFkb3cvc2hhZG93LXJvb3QtanMtYXBpLmh0bWwKQEAgLTEwLDkgKzEwLDExIEBAIGRlc2NyaXB0 aW9uKCJUZXN0cyBmb3IgU2hhZG93Um9vdCBKUyBBUElzLiBDYW4gb25seSBydW4gd2l0aGluIERS VCIpOwogCiBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQogICAgIGxheW91dFRlc3RD b250cm9sbGVyLmR1bXBBc1RleHQoKTsKK3Nob3VsZFRocm93KCJuZXcgV2ViS2l0U2hhZG93Um9v dCgpIik7CitzaG91bGRUaHJvdygibmV3IFdlYktpdFNoYWRvd1Jvb3QodW5kZWZpbmVkKSIpOwor c2hvdWxkVGhyb3coIm5ldyBXZWJLaXRTaGFkb3dSb290KDEpIik7CiB2YXIgc2hhZG93SG9zdCA9 IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpOwotaW50ZXJuYWxzLmVuc3VyZVNoYWRvd1Jv b3Qoc2hhZG93SG9zdCk7Ci12YXIgc2hhZG93Um9vdCA9IGludGVybmFscy5zaGFkb3dSb290KHNo YWRvd0hvc3QpOwordmFyIHNoYWRvd1Jvb3QgPSBuZXcgV2ViS2l0U2hhZG93Um9vdChzaGFkb3dI b3N0KTsKIHNob3VsZEJlKCJzaGFkb3dIb3N0IiwgInNoYWRvd1Jvb3QuaG9zdCIpOwogCiA8L3Nj cmlwdD4K 124059 2012-01-25 20:57:10 -0800 2012-01-25 22:10:55 -0800 Update bug-76354-20120126135709.patch text/plain 6558 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1ODMyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNmMwYjE1MGI0OWRjMjA0 MzMzZmUzOGFiZjVkY2U2MzNkZjY1YjQ2My4uOTE3ZDg3OGViYmMyOThhYzM4ZTg5MjE3MTQyNjVi MWM5ODQ1NDU1MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEyLTAxLTIzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgYSBTaGFkb3dSb290 IGNvbnN0cnVjdG9yIGFzICdXZWJLaXRTaGFkb3dSb290Q29uc3RydWN0b3InLCBlbmFibGVkIGJ5 IFNIQURPV19ET00gZmxhZy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTc2MzU0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgV2UgdXNlIHZlbmRvci1wcmVmaXhlZCBuYW1lLCAnV2ViS2l0U2hhZG93Um9vdCcs IGluc3RlYWQgb2YgJ1NoYWRvd1Jvb3QnCisgICAgICAgIHNpbmNlIHRoaXMgaXMgYW4gdW5kZXIg ZGV2ZWxvcG1lbnQgZmVhdHVyZS4KKworICAgICAgICAqIGRvbS9TaGFkb3dSb290LmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlNoYWRvd1Jvb3Q6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlKToK KyAgICAgICAgKiBkb20vU2hhZG93Um9vdC5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAg IChTaGFkb3dSb290KToKKyAgICAgICAgKiBkb20vU2hhZG93Um9vdC5pZGw6CisgICAgICAgICog cGFnZS9ET01XaW5kb3cuaWRsOgorCiAyMDEyLTAxLTI0ICBLZW4gQnVjaGFuYW4gIDxrZW5yYkBj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgQ3Jhc2ggaW4gdXBkYXRlRmlyc3RMZXR0ZXIoKSBmcm9t IHVubmVjZXNzYXJ5IGFub255bW91cyBibG9jawpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv ZG9tL1NoYWRvd1Jvb3QuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuY3BwCmlu ZGV4IDIyOWQ1NTgxNWE3ZmFlZWU0NzhhZDI5YTcwOGIyNTg5NmIyNGVhNmMuLjQwMjJlOWFlYTE3 Njg0ODE4MjI3MmIwNzg0MmMzOWM5NTQxMmY3OGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2RvbS9TaGFkb3dSb290LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5j cHAKQEAgLTUzLDYgKzUzLDE5IEBAIFNoYWRvd1Jvb3Q6On5TaGFkb3dSb290KCkKIHsKIH0KIAor UGFzc1JlZlB0cjxTaGFkb3dSb290PiBTaGFkb3dSb290OjpjcmVhdGUoRWxlbWVudCogZWxlbWVu dCwgRXhjZXB0aW9uQ29kZSYgZWMpCit7CisgICAgaWYgKCFlbGVtZW50IHx8IGVsZW1lbnQtPnNo YWRvd1Jvb3QoKSkgeworICAgICAgICBlYyA9IEhJRVJBUkNIWV9SRVFVRVNUX0VSUjsKKyAgICAg ICAgcmV0dXJuIDA7CisgICAgfQorICAgIFJlZlB0cjxTaGFkb3dSb290PiBzaGFkb3dSb290ID0g Y3JlYXRlKGVsZW1lbnQtPmRvY3VtZW50KCkpOworICAgIGVsZW1lbnQtPnNldFNoYWRvd1Jvb3Qo c2hhZG93Um9vdCwgZWMpOworICAgIGlmIChlYykKKyAgICAgICAgcmV0dXJuIDA7CisgICAgcmV0 dXJuIHNoYWRvd1Jvb3QucmVsZWFzZSgpOworfQorCiBTdHJpbmcgU2hhZG93Um9vdDo6bm9kZU5h bWUoKSBjb25zdAogewogICAgIHJldHVybiAiI3NoYWRvdy1yb290IjsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290LmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93 Um9vdC5oCmluZGV4IGRhZTg5NWNhNzM3MjZkNGQ0Y2NhOTk4NDdiOTA5ZTAxZDc4NTgzZTguLjgz NmU0YWFhY2Q0ZjZjZTE1ZjdjYWVjYmI4YmZiNzY2NDdiZmNkN2EgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRv d1Jvb3QuaApAQCAtMjcsMTcgKzI3LDE5IEBACiAjaWZuZGVmIFNoYWRvd1Jvb3RfaAogI2RlZmlu ZSBTaGFkb3dSb290X2gKIAorI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKICNpbmNsdWRlICJU cmVlU2NvcGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitjbGFzcyBDb250ZW50SW5jbHVz aW9uU2VsZWN0b3I7CiBjbGFzcyBEb2N1bWVudDsKIGNsYXNzIEhUTUxDb250ZW50RWxlbWVudDsK LWNsYXNzIENvbnRlbnRJbmNsdXNpb25TZWxlY3RvcjsKIAogY2xhc3MgU2hhZG93Um9vdCA6IHB1 YmxpYyBUcmVlU2NvcGUgewogcHVibGljOgogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNoYWRvd1Jv b3Q+IGNyZWF0ZShEb2N1bWVudCopOworICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNoYWRvd1Jvb3Q+ IGNyZWF0ZShFbGVtZW50KiwgRXhjZXB0aW9uQ29kZSYpOwogCiAgICAgdm9pZCByZWNhbGNTaGFk b3dUcmVlU3R5bGUoU3R5bGVDaGFuZ2UpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9k b20vU2hhZG93Um9vdC5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5pZGwKaW5k ZXggOWE4MDkzMzU4YmRjMGZmZjAxYzg2OTczNWUwYTQzZmQyMzAzYTEzYy4uYmJjY2U5OGFjM2Qy Y2QwZTRjZGUwNjQ2ODhmNGZlYTY2ZmRhMTBiOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv ZG9tL1NoYWRvd1Jvb3QuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290Lmlk bApAQCAtMjgsNyArMjgsOSBAQCBtb2R1bGUgY29yZSB7CiAKICAgICBpbnRlcmZhY2UgWwogICAg ICAgICBDb25kaXRpb25hbD1TSEFET1dfRE9NLAotICAgICAgICBFbmFibGVkQXRSdW50aW1lPXNo YWRvd0RPTQorICAgICAgICBFbmFibGVkQXRSdW50aW1lPXNoYWRvd0RPTSwKKyAgICAgICAgQ29u c3RydWN0b3IoaW4gRWxlbWVudCBob3N0KSwKKyAgICAgICAgQ29uc3RydWN0b3JSYWlzZXNFeGNl cHRpb24KICAgICBdIFNoYWRvd1Jvb3QgOiBOb2RlIHsKICAgICAgICAgcmVhZG9ubHkgYXR0cmli dXRlIEVsZW1lbnQgaG9zdDsKICAgICB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFn ZS9ET01XaW5kb3cuaWRsIGIvU291cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaWRsCmluZGV4 IDk5ZTJiYzQwMjczYWZkMWE4MDQ4N2U1M2RjNGU5YzI5NmY5Njc0YmIuLjk3NGI4NGRhYzg3NDMz ZTQxMjdiMzA4MWRlMGY1MDEwY2E1YzZmNzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvRE9NV2luZG93LmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwK QEAgLTM5OCw2ICszOTgsNyBAQCBtb2R1bGUgd2luZG93IHsKICAgICAgICAgYXR0cmlidXRlIEVu dGl0eUNvbnN0cnVjdG9yIEVudGl0eTsKICAgICAgICAgYXR0cmlidXRlIEVudGl0eVJlZmVyZW5j ZUNvbnN0cnVjdG9yIEVudGl0eVJlZmVyZW5jZTsKICAgICAgICAgYXR0cmlidXRlIFByb2Nlc3Np bmdJbnN0cnVjdGlvbkNvbnN0cnVjdG9yIFByb2Nlc3NpbmdJbnN0cnVjdGlvbjsKKyAgICAgICAg YXR0cmlidXRlIFtDb25kaXRpb25hbD1TSEFET1dfRE9NLCBFbmFibGVkQXRSdW50aW1lPXNoYWRv d0RPTV0gU2hhZG93Um9vdENvbnN0cnVjdG9yIFdlYktpdFNoYWRvd1Jvb3Q7CiAKICAgICAgICAg YXR0cmlidXRlIEhUTUxEb2N1bWVudENvbnN0cnVjdG9yIEhUTUxEb2N1bWVudDsKIApkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4 IDg0YzM0MjMwYTUyZThkYWE4ZGM5ODMwMTZiYjgwNGVkYTE0OTQxYzkuLjM2ZTY3YTJkMzcxMGY4 NmVkMmVlM2VjNGUyZDNkOWM4YzA1MzRiMmIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMi0w MS0yNCAgSGF5YXRvIEl0byAgPGhheWF0b0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIGEg U2hhZG93Um9vdCBjb25zdHJ1Y3RvciBhcyAnV2ViS2l0U2hhZG93Um9vdENvbnN0cnVjdG9yJywg ZW5hYmxlZCBieSBTSEFET1dfRE9NIGZsYWcuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD03NjM1NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIFdlIHVzZSB2ZW5kb3ItcHJlZml4ZWQgbmFtZSwgJ1dlYktpdFNo YWRvd1Jvb3QnLCBpbnN0ZWFkIG9mICdTaGFkb3dSb290JworICAgICAgICBzaW5jZSB0aGlzIGlz IGFuIHVuZGVyIGRldmVsb3BtZW50IGZlYXR1cmUuCisKKyAgICAgICAgKiBmYXN0L2RvbS9zaGFk b3cvc2hhZG93LXJvb3QtanMtYXBpLmh0bWw6CisKIDIwMTItMDEtMjQgIEFkYW0gQmFydGggIDxh YmFydGhAd2Via2l0Lm9yZz4KIAogICAgICAgICBBZGQgTGludXgtc3BlY2lmaWMgb3ZlcnJpZGVz LgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpz LWFwaS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJv b3QtanMtYXBpLWV4cGVjdGVkLnR4dAppbmRleCAwZTA0Y2NjYWZjYjM2Y2UxYTlhYzc0MjQ5MmM4 OGI5NDY1YzdmN2JjLi4xZTlhNzY2NTA0NGNiZjkzNjVhODMyN2U3NjE3YWE1MDllMjlkNzllIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJvb3QtanMtYXBp LWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJv b3QtanMtYXBpLWV4cGVjdGVkLnR4dApAQCAtMyw3ICszLDEyIEBAIFRlc3RzIGZvciBTaGFkb3dS b290IEpTIEFQSXMuIENhbiBvbmx5IHJ1biB3aXRoaW4gRFJUCiBPbiBzdWNjZXNzLCB5b3Ugd2ls bCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01Q TEVURSIuCiAKIAorUEFTUyBuZXcgV2ViS2l0U2hhZG93Um9vdCgpIHRocmV3IGV4Y2VwdGlvbiBU eXBlRXJyb3I6IE5vdCBlbm91Z2ggYXJndW1lbnRzLgorUEFTUyBuZXcgV2ViS2l0U2hhZG93Um9v dCh1bmRlZmluZWQpIHRocmV3IGV4Y2VwdGlvbiBFcnJvcjogSElFUkFSQ0hZX1JFUVVFU1RfRVJS OiBET00gRXhjZXB0aW9uIDMuCitQQVNTIG5ldyBXZWJLaXRTaGFkb3dSb290KG51bGwpIHRocmV3 IGV4Y2VwdGlvbiBFcnJvcjogSElFUkFSQ0hZX1JFUVVFU1RfRVJSOiBET00gRXhjZXB0aW9uIDMu CitQQVNTIG5ldyBXZWJLaXRTaGFkb3dSb290KDEpIHRocmV3IGV4Y2VwdGlvbiBFcnJvcjogSElF UkFSQ0hZX1JFUVVFU1RfRVJSOiBET00gRXhjZXB0aW9uIDMuCiBQQVNTIHNoYWRvd0hvc3QgaXMg c2hhZG93Um9vdC5ob3N0CitQQVNTIG5ldyBXZWJLaXRTaGFkb3dSb290KHNoYWRvd0hvc3QpIHRo cmV3IGV4Y2VwdGlvbiBFcnJvcjogSElFUkFSQ0hZX1JFUVVFU1RfRVJSOiBET00gRXhjZXB0aW9u IDMuCiBQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCiAKIFRFU1QgQ09NUExFVEUKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NoYWRvdy9zaGFkb3ctcm9vdC1qcy1hcGku aHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NoYWRvdy9zaGFkb3ctcm9vdC1qcy1hcGkuaHRt bAppbmRleCBjZDZjNDQ2ZjJhODhmMDU2YWZmZmU0MDU0ODI5ZDExYzJmNDQ3YzQ5Li5lYmE3NTA1 NzY2ZmJkYWM2YzU3OTM1YTliNzA3ODcwYzI2NjM1N2JlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJvb3QtanMtYXBpLmh0bWwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpzLWFwaS5odG1sCkBAIC0xMCwxMCArMTAs MTQgQEAgZGVzY3JpcHRpb24oIlRlc3RzIGZvciBTaGFkb3dSb290IEpTIEFQSXMuIENhbiBvbmx5 IHJ1biB3aXRoaW4gRFJUIik7CiAKIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCiAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworc2hvdWxkVGhyb3coIm5ldyBX ZWJLaXRTaGFkb3dSb290KCkiKTsKK3Nob3VsZFRocm93KCJuZXcgV2ViS2l0U2hhZG93Um9vdCh1 bmRlZmluZWQpIik7CitzaG91bGRUaHJvdygibmV3IFdlYktpdFNoYWRvd1Jvb3QobnVsbCkiKTsK K3Nob3VsZFRocm93KCJuZXcgV2ViS2l0U2hhZG93Um9vdCgxKSIpOwogdmFyIHNoYWRvd0hvc3Qg PSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdkaXYnKTsKLWludGVybmFscy5lbnN1cmVTaGFkb3dS b290KHNoYWRvd0hvc3QpOwotdmFyIHNoYWRvd1Jvb3QgPSBpbnRlcm5hbHMuc2hhZG93Um9vdChz aGFkb3dIb3N0KTsKK3ZhciBzaGFkb3dSb290ID0gbmV3IFdlYktpdFNoYWRvd1Jvb3Qoc2hhZG93 SG9zdCk7CiBzaG91bGRCZSgic2hhZG93SG9zdCIsICJzaGFkb3dSb290Lmhvc3QiKTsKK3Nob3Vs ZFRocm93KCJuZXcgV2ViS2l0U2hhZG93Um9vdChzaGFkb3dIb3N0KSIpOwogCiA8L3NjcmlwdD4K IDxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3Njcmlw dD4K 124063 2012-01-25 22:11:02 -0800 2012-01-29 19:47:52 -0800 makes sure no side-effects bug-76354-20120126151100.patch text/plain 6668 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1ODMyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNmMwYjE1MGI0OWRjMjA0 MzMzZmUzOGFiZjVkY2U2MzNkZjY1YjQ2My4uYjJkZGYzN2E3N2YxOTYwZWQ0OThhYTA3NzZkOGRm OGZmMTZkODkwZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEyLTAxLTIzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgYSBTaGFkb3dSb290 IGNvbnN0cnVjdG9yIGFzICdXZWJLaXRTaGFkb3dSb290Q29uc3RydWN0b3InLCBlbmFibGVkIGJ5 IFNIQURPV19ET00gZmxhZy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTc2MzU0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgV2UgdXNlIHZlbmRvci1wcmVmaXhlZCBuYW1lLCAnV2ViS2l0U2hhZG93Um9vdCcs IGluc3RlYWQgb2YgJ1NoYWRvd1Jvb3QnCisgICAgICAgIHNpbmNlIHRoaXMgaXMgYSBmZWF0dXJl IHVuZGVyIGRldmVsb3BtZW50LgorCisgICAgICAgICogZG9tL1NoYWRvd1Jvb3QuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6U2hhZG93Um9vdDo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAqIGRvbS9TaGFkb3dSb290Lmg6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAg KFNoYWRvd1Jvb3QpOgorICAgICAgICAqIGRvbS9TaGFkb3dSb290LmlkbDoKKyAgICAgICAgKiBw YWdlL0RPTVdpbmRvdy5pZGw6CisKIDIwMTItMDEtMjQgIEtlbiBCdWNoYW5hbiAgPGtlbnJiQGNo cm9taXVtLm9yZz4KIAogICAgICAgICBDcmFzaCBpbiB1cGRhdGVGaXJzdExldHRlcigpIGZyb20g dW5uZWNlc3NhcnkgYW5vbnltb3VzIGJsb2NrCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9k b20vU2hhZG93Um9vdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93Um9vdC5jcHAKaW5k ZXggMjI5ZDU1ODE1YTdmYWVlZTQ3OGFkMjlhNzA4YjI1ODk2YjI0ZWE2Yy4uNDAyMmU5YWVhMTc2 ODQ4MTgyMjcyYjA3ODQyYzM5Yzk1NDEyZjc4YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv ZG9tL1NoYWRvd1Jvb3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290LmNw cApAQCAtNTMsNiArNTMsMTkgQEAgU2hhZG93Um9vdDo6flNoYWRvd1Jvb3QoKQogewogfQogCitQ YXNzUmVmUHRyPFNoYWRvd1Jvb3Q+IFNoYWRvd1Jvb3Q6OmNyZWF0ZShFbGVtZW50KiBlbGVtZW50 LCBFeGNlcHRpb25Db2RlJiBlYykKK3sKKyAgICBpZiAoIWVsZW1lbnQgfHwgZWxlbWVudC0+c2hh ZG93Um9vdCgpKSB7CisgICAgICAgIGVjID0gSElFUkFSQ0hZX1JFUVVFU1RfRVJSOworICAgICAg ICByZXR1cm4gMDsKKyAgICB9CisgICAgUmVmUHRyPFNoYWRvd1Jvb3Q+IHNoYWRvd1Jvb3QgPSBj cmVhdGUoZWxlbWVudC0+ZG9jdW1lbnQoKSk7CisgICAgZWxlbWVudC0+c2V0U2hhZG93Um9vdChz aGFkb3dSb290LCBlYyk7CisgICAgaWYgKGVjKQorICAgICAgICByZXR1cm4gMDsKKyAgICByZXR1 cm4gc2hhZG93Um9vdC5yZWxlYXNlKCk7Cit9CisKIFN0cmluZyBTaGFkb3dSb290Ojpub2RlTmFt ZSgpIGNvbnN0CiB7CiAgICAgcmV0dXJuICIjc2hhZG93LXJvb3QiOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dS b290LmgKaW5kZXggZGFlODk1Y2E3MzcyNmQ0ZDRjY2E5OTg0N2I5MDllMDFkNzg1ODNlOC4uODM2 ZTRhYWFjZDRmNmNlMTVmN2NhZWNiYjhiZmI3NjY0N2JmY2Q3YSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2hhZG93 Um9vdC5oCkBAIC0yNywxNyArMjcsMTkgQEAKICNpZm5kZWYgU2hhZG93Um9vdF9oCiAjZGVmaW5l IFNoYWRvd1Jvb3RfaAogCisjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2luY2x1ZGUgIlRy ZWVTY29wZS5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNzIENvbnRlbnRJbmNsdXNp b25TZWxlY3RvcjsKIGNsYXNzIERvY3VtZW50OwogY2xhc3MgSFRNTENvbnRlbnRFbGVtZW50Owot Y2xhc3MgQ29udGVudEluY2x1c2lvblNlbGVjdG9yOwogCiBjbGFzcyBTaGFkb3dSb290IDogcHVi bGljIFRyZWVTY29wZSB7CiBwdWJsaWM6CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8U2hhZG93Um9v dD4gY3JlYXRlKERvY3VtZW50Kik7CisgICAgc3RhdGljIFBhc3NSZWZQdHI8U2hhZG93Um9vdD4g Y3JlYXRlKEVsZW1lbnQqLCBFeGNlcHRpb25Db2RlJik7CiAKICAgICB2b2lkIHJlY2FsY1NoYWRv d1RyZWVTdHlsZShTdHlsZUNoYW5nZSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Rv bS9TaGFkb3dSb290LmlkbCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TaGFkb3dSb290LmlkbAppbmRl eCA5YTgwOTMzNThiZGMwZmZmMDFjODY5NzM1ZTBhNDNmZDIzMDNhMTNjLi5iYmNjZTk4YWMzZDJj ZDBlNGNkZTA2NDY4OGY0ZmVhNjZmZGExMGI4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9k b20vU2hhZG93Um9vdC5pZGwKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL1NoYWRvd1Jvb3QuaWRs CkBAIC0yOCw3ICsyOCw5IEBAIG1vZHVsZSBjb3JlIHsKIAogICAgIGludGVyZmFjZSBbCiAgICAg ICAgIENvbmRpdGlvbmFsPVNIQURPV19ET00sCi0gICAgICAgIEVuYWJsZWRBdFJ1bnRpbWU9c2hh ZG93RE9NCisgICAgICAgIEVuYWJsZWRBdFJ1bnRpbWU9c2hhZG93RE9NLAorICAgICAgICBDb25z dHJ1Y3RvcihpbiBFbGVtZW50IGhvc3QpLAorICAgICAgICBDb25zdHJ1Y3RvclJhaXNlc0V4Y2Vw dGlvbgogICAgIF0gU2hhZG93Um9vdCA6IE5vZGUgewogICAgICAgICByZWFkb25seSBhdHRyaWJ1 dGUgRWxlbWVudCBob3N0OwogICAgIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdl L0RPTVdpbmRvdy5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5pZGwKaW5kZXgg OTllMmJjNDAyNzNhZmQxYTgwNDg3ZTUzZGM0ZTljMjk2Zjk2NzRiYi4uOTc0Yjg0ZGFjODc0MzNl NDEyN2IzMDgxZGUwZjUwMTBjYTVjNmY3OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFn ZS9ET01XaW5kb3cuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmlkbApA QCAtMzk4LDYgKzM5OCw3IEBAIG1vZHVsZSB3aW5kb3cgewogICAgICAgICBhdHRyaWJ1dGUgRW50 aXR5Q29uc3RydWN0b3IgRW50aXR5OwogICAgICAgICBhdHRyaWJ1dGUgRW50aXR5UmVmZXJlbmNl Q29uc3RydWN0b3IgRW50aXR5UmVmZXJlbmNlOwogICAgICAgICBhdHRyaWJ1dGUgUHJvY2Vzc2lu Z0luc3RydWN0aW9uQ29uc3RydWN0b3IgUHJvY2Vzc2luZ0luc3RydWN0aW9uOworICAgICAgICBh dHRyaWJ1dGUgW0NvbmRpdGlvbmFsPVNIQURPV19ET00sIEVuYWJsZWRBdFJ1bnRpbWU9c2hhZG93 RE9NXSBTaGFkb3dSb290Q29uc3RydWN0b3IgV2ViS2l0U2hhZG93Um9vdDsKIAogICAgICAgICBh dHRyaWJ1dGUgSFRNTERvY3VtZW50Q29uc3RydWN0b3IgSFRNTERvY3VtZW50OwogCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXgg ODRjMzQyMzBhNTJlOGRhYThkYzk4MzAxNmJiODA0ZWRhMTQ5NDFjOS4uNmNhMWIxMTAyODZhMzQ5 ZjM1NDliNGI3MTYwZWQwZTM5NDMxMmExOCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTAx LTI0ICBIYXlhdG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgYSBT aGFkb3dSb290IGNvbnN0cnVjdG9yIGFzICdXZWJLaXRTaGFkb3dSb290Q29uc3RydWN0b3InLCBl bmFibGVkIGJ5IFNIQURPV19ET00gZmxhZy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTc2MzU0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgV2UgdXNlIHZlbmRvci1wcmVmaXhlZCBuYW1lLCAnV2ViS2l0U2hh ZG93Um9vdCcsIGluc3RlYWQgb2YgJ1NoYWRvd1Jvb3QnCisgICAgICAgIHNpbmNlIHRoaXMgaXMg YSBmZWF0dXJlIHVuZGVyIGRldmVsb3BtZW50LgorCisgICAgICAgICogZmFzdC9kb20vc2hhZG93 L3NoYWRvdy1yb290LWpzLWFwaS5odG1sOgorCiAyMDEyLTAxLTI0ICBBZGFtIEJhcnRoICA8YWJh cnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAgQWRkIExpbnV4LXNwZWNpZmljIG92ZXJyaWRlcy4K ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL3NoYWRvdy9zaGFkb3ctcm9vdC1qcy1h cGktZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290 LWpzLWFwaS1leHBlY3RlZC50eHQKaW5kZXggMGUwNGNjY2FmY2IzNmNlMWE5YWM3NDI0OTJjODhi OTQ2NWM3ZjdiYy4uNDkxNTJiNWMwMTY2OTllNzRkMjQ1MGIxYzRkMjJkMTQ3Y2ZjZjdmMiAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290LWpzLWFwaS1l eHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290 LWpzLWFwaS1leHBlY3RlZC50eHQKQEAgLTMsNiArMywxMyBAQCBUZXN0cyBmb3IgU2hhZG93Um9v dCBKUyBBUElzLiBDYW4gb25seSBydW4gd2l0aGluIERSVAogT24gc3VjY2VzcywgeW91IHdpbGwg c2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExF VEUiLgogCiAKK1BBU1MgbmV3IFdlYktpdFNoYWRvd1Jvb3QoKSB0aHJldyBleGNlcHRpb24gVHlw ZUVycm9yOiBOb3QgZW5vdWdoIGFyZ3VtZW50cy4KK1BBU1MgbmV3IFdlYktpdFNoYWRvd1Jvb3Qo dW5kZWZpbmVkKSB0aHJldyBleGNlcHRpb24gRXJyb3I6IEhJRVJBUkNIWV9SRVFVRVNUX0VSUjog RE9NIEV4Y2VwdGlvbiAzLgorUEFTUyBuZXcgV2ViS2l0U2hhZG93Um9vdChudWxsKSB0aHJldyBl eGNlcHRpb24gRXJyb3I6IEhJRVJBUkNIWV9SRVFVRVNUX0VSUjogRE9NIEV4Y2VwdGlvbiAzLgor UEFTUyBuZXcgV2ViS2l0U2hhZG93Um9vdCgxKSB0aHJldyBleGNlcHRpb24gRXJyb3I6IEhJRVJB UkNIWV9SRVFVRVNUX0VSUjogRE9NIEV4Y2VwdGlvbiAzLgorUEFTUyBzaGFkb3dIb3N0IGlzIHNo YWRvd1Jvb3QuaG9zdAorUEFTUyBuZXcgV2ViS2l0U2hhZG93Um9vdChzaGFkb3dIb3N0KSB0aHJl dyBleGNlcHRpb24gRXJyb3I6IEhJRVJBUkNIWV9SRVFVRVNUX0VSUjogRE9NIEV4Y2VwdGlvbiAz LgorVGhlIHByZXZpb3VzIHRlc3Qgc2hvdWxkIG5vdCBoYXZlIHNpZGUgZWZmZWN0cy4KIFBBU1Mg c2hhZG93SG9zdCBpcyBzaGFkb3dSb290Lmhvc3QKIFBBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlz IHRydWUKIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1y b290LWpzLWFwaS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vc2hhZG93L3NoYWRvdy1yb290 LWpzLWFwaS5odG1sCmluZGV4IGNkNmM0NDZmMmE4OGYwNTZhZmZmZTQwNTQ4MjlkMTFjMmY0NDdj NDkuLmE1ODA2MDVhMGVhNjk4M2Q4OTc3NzRkOGQ2NzY0NWZiODJmNDgyZTkgMTAwNjQ0Ci0tLSBh L0xheW91dFRlc3RzL2Zhc3QvZG9tL3NoYWRvdy9zaGFkb3ctcm9vdC1qcy1hcGkuaHRtbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9zaGFkb3cvc2hhZG93LXJvb3QtanMtYXBpLmh0bWwKQEAg LTEwLDkgKzEwLDE1IEBAIGRlc2NyaXB0aW9uKCJUZXN0cyBmb3IgU2hhZG93Um9vdCBKUyBBUElz LiBDYW4gb25seSBydW4gd2l0aGluIERSVCIpOwogCiBpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKQogICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKK3Nob3VsZFRo cm93KCJuZXcgV2ViS2l0U2hhZG93Um9vdCgpIik7CitzaG91bGRUaHJvdygibmV3IFdlYktpdFNo YWRvd1Jvb3QodW5kZWZpbmVkKSIpOworc2hvdWxkVGhyb3coIm5ldyBXZWJLaXRTaGFkb3dSb290 KG51bGwpIik7CitzaG91bGRUaHJvdygibmV3IFdlYktpdFNoYWRvd1Jvb3QoMSkiKTsKIHZhciBz aGFkb3dIb3N0ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7Ci1pbnRlcm5hbHMuZW5z dXJlU2hhZG93Um9vdChzaGFkb3dIb3N0KTsKLXZhciBzaGFkb3dSb290ID0gaW50ZXJuYWxzLnNo YWRvd1Jvb3Qoc2hhZG93SG9zdCk7Cit2YXIgc2hhZG93Um9vdCA9IG5ldyBXZWJLaXRTaGFkb3dS b290KHNoYWRvd0hvc3QpOworc2hvdWxkQmUoInNoYWRvd0hvc3QiLCAic2hhZG93Um9vdC5ob3N0 Iik7CitzaG91bGRUaHJvdygibmV3IFdlYktpdFNoYWRvd1Jvb3Qoc2hhZG93SG9zdCkiKTsKK2Rl YnVnKCdUaGUgcHJldmlvdXMgdGVzdCBzaG91bGQgbm90IGhhdmUgc2lkZSBlZmZlY3RzLicpOwog c2hvdWxkQmUoInNoYWRvd0hvc3QiLCAic2hhZG93Um9vdC5ob3N0Iik7CiAKIDwvc2NyaXB0Pgo=