158509 2016-06-07 18:45:38 -0700 [WebIDL] Add support for sequence<Dictionary> 2016-10-12 23:24:03 -0700 1 1 1 Unclassified WebKit Bindings WebKit Nightly Build Unspecified Unspecified RESOLVED DUPLICATE 163381 P2 Normal --- 158508 1 rawinder.webkit rawinder.webkit annevk brian cdumez cgarcia commit-queue darin dino esprehn+autocc graouts kondapallykalyan nikos.andronikos sam oldest_to_newest 1200286 0 rawinder.webkit 2016-06-07 18:45:38 -0700 We need to generate bindings for Bug #158508, where the constructor takes a parameter "keyframes" - this parameter will be implemented as type "sequence<Dictionary>". Currently, there is no support for sequence<Dictionary>. 1225296 1 287611 rawinder.webkit 2016-09-01 01:58:15 -0700 Created attachment 287611 Patch 1226145 2 287611 darin 2016-09-03 10:58:49 -0700 Comment on attachment 287611 Patch Dictionary is a deprecated type. We should not be using Dictionary for any new code. Where were you planning on using a sequence<Dictionary> and what is the specification that calls for that? 1226146 3 darin 2016-09-03 10:59:12 -0700 Oh, I see. Let me look at bug 158508. 1226147 4 darin 2016-09-03 11:01:20 -0700 I’m really concerned that the specification says: "The type of this argument cannot be expressed in WebIDL since it relies on a partially-open dictionary type." We need to fix WebIDL to be able to express these kinds of things, not write code that exposes JavaScript objets directly to our DOM using the WebCore::Dictionary hack. I also don’t understand what "partially open" means here. 1226571 5 nikos.andronikos 2016-09-05 21:20:57 -0700 Partially open means that the set of properties allowed on the dictionary is not defined ahead of time (because the set of animatable properties isn't fixed). My understanding, from chatting to Brian Birtles (editor of Web Animations) is that support for this could be added to WebIDL, the WebIDL editors have given their approval, but it's not going to happen in a reasonable time frame and we don't want to block Web Animations waiting for it. The only advantage to adding support for partially open dictionaries in WebIDL is that we can generate the list of allowable properties for the dictionary in the bindings layer. Without it, we'll have to do so in the animation code. 1226572 6 sam 2016-09-05 21:23:12 -0700 (In reply to comment #4) > I’m really concerned that the specification says: > > "The type of this argument cannot be expressed in WebIDL since it relies on > a partially-open dictionary type." > > We need to fix WebIDL to be able to express these kinds of things, not write > code that exposes JavaScript objets directly to our DOM using the > WebCore::Dictionary hack. > > I also don’t understand what "partially open" means here. Dictionary is too powerful to use in most places. What are the actual constraints on the keyframe dictionary-like objects. From a cursory look at the Web Animations spec, it looks like you can do things like: [{ color: 'red' }] bug also [{ color: ['red', 'green'] } So, far it sounds like we would want an internal representation that is something like: struct { String easing; CompositeOperation composite; Vector<std::pair<String, std::variant<String, Vector<String>>>; } or maybe: struct { String easing; CompositeOperation composite; HashMap<String, std::variant<String, Vector<String>>>; } (I believe the variant could be replaced with a straight String in cases where the "allow lists" bit is false). So, what we need is new dictionary-like syntax in WebIDL to express this conversion. The most straightforward syntax I can think of looks something like this: [HalfOpenType=(long or sequence<double>)] dictionary BasePropertyIndexedKeyframe { DOMString easing = "linear"; CompositeOperation composite; }; Though the name is horrible and obviously needs to change, it would expect a struct like: struct BasePropertyIndexedKeyframe { String easing; CompositeOperation composite; HashMap<String, std::variant<int, Vector<double>>>; // Could be a Vector too. } 1226575 7 rawinder.webkit 2016-09-05 21:28:42 -0700 > Dictionary is a deprecated type. Could you please clarify - do you mean Dictionary as a class in WebKit? > We need to fix WebIDL to be able to express these kinds of things, not write code that exposes JavaScript objets directly to our DOM using the WebCore::Dictionary hack. Further, to the comment that Nikos made. We would only allow animatable properties on the Element to be changed through the keyframes parameter - I don't think that this would expose the JavaScript objects directly - is this right? 1226631 8 brian 2016-09-06 03:19:35 -0700 (In reply to comment #6) > From a cursory look at > the Web Animations spec, it looks like you can do things like: > > [{ color: 'red' }] > > bug also > > [{ color: ['red', 'green'] } Actually, the spec allows the following three forms: [ { color: 'red' }, { color: 'green' } ] or: { color: [ 'red', 'green' ] } or: { color: 'red' } (Note that { opacity: [ 0, 1 ] } also works since values are read as strings) Note that the getKeyframes() API returns values using the first of the above three forms. In Gecko internally we normalize the above three inputs to the above first form. Also, bear in mind that since custom properties can be animated, the set of properties that can be animated is effectively open-ended (however the spec defines that we only read properties off the input object whose key is a recognized animatable property including where the key matches the syntax for a custom property name). 1226682 9 darin 2016-09-06 08:33:38 -0700 (In reply to comment #7) > > Dictionary is a deprecated type. > > Could you please clarify - do you mean Dictionary as a class in WebKit? Yes, Dictionary as a class in WebKit that bridges between JavaScript and DOM code is obsolete and should not be used in new code. And that includes the Dictionary syntax in IDL. To give you a rough idea of why: It is not safe to run arbitrary JavaScript in the middle of the DOM code. Each time you get a JavaScript property it could be doing anything, including navigating to another web page, closing the browser window, etc. This needs to be done by the bindings, not in the middle of DOM code. The precise order that things are read out of a JavaScript object is observable behavior. 1226757 10 sam 2016-09-06 11:09:39 -0700 (In reply to comment #8) > (In reply to comment #6) > > From a cursory look at > > the Web Animations spec, it looks like you can do things like: > > > > [{ color: 'red' }] > > > > bug also > > > > [{ color: ['red', 'green'] } > > Actually, the spec allows the following three forms: > > [ { color: 'red' }, { color: 'green' } ] > > or: > > { color: [ 'red', 'green' ] } > > or: > > { color: 'red' } > > Can you combine the two? e.g.: [ { color: ['red', 'blue'] }, { color: 'green' } ] If not, that means the c++ type is something like: std::variant< Vector<HashMap<String, String>>, HashMap<String, std::variant<String, Vector<String>> > If so, something like: std::variant< Vector<HashMap<String, std::variant<String, Vector<String>>>, HashMap<String, std::variant<String, Vector<String>> > > (Note that { opacity: [ 0, 1 ] } also works since values are read as strings) > > Note that the getKeyframes() API returns values using the first of the above > three forms. In Gecko internally we normalize the above three inputs to the > above first form. > > Also, bear in mind that since custom properties can be animated, the set of > properties that can be animated is effectively open-ended (however the spec > defines that we only read properties off the input object whose key is a > recognized animatable property including where the key matches the syntax > for a custom property name). Thanks Brian. 1226990 11 brian 2016-09-06 18:18:39 -0700 (In reply to comment #10) > Can you combine the two? e.g.: > > [ { color: ['red', 'blue'] }, { color: 'green' } ] No. (Specifically, the procedure to process a keyframes argument[1] first checks if the object is iterable or not, and if it *is*, it passes "allow lists = false" when it calls the procedure to read each of the keyframe objects in the iterable.) [1] https://w3c.github.io/web-animations/#process-a-keyframes-argument 1227080 12 rawinder.webkit 2016-09-06 23:59:30 -0700 (In reply to comment #6) > From a cursory look at > the Web Animations spec, it looks like you can do things like: > > [{ color: 'red' }] > > bug also > > [{ color: ['red', 'green'] } As there are multiple methods to pass in keyframes, I think we should try and implement just the canonical form first (and the others can come later), i.e.: [{ offset: 0, margin: "10px" }, { offset: 1, margin: "20px 30px 40px 50px" }] 1227081 13 rawinder.webkit 2016-09-07 00:00:28 -0700 (In reply to comment #9) > (In reply to comment #7) > > > Dictionary is a deprecated type. > > > > Could you please clarify - do you mean Dictionary as a class in WebKit? > > Yes, Dictionary as a class in WebKit that bridges between JavaScript and DOM > code is obsolete and should not be used in new code. And that includes the > Dictionary syntax in IDL. If we cannot specify Dictionary on the IDL interface, e.g.: Constructor([Default=Undefined] Element? target, sequence<Dictionary> keyframes) Do you have any thoughts on how I should proceed? I don’t think defining a dictionary (e.g. dictionary KeyframeInit {…};) is an option as there are too many CSS and SVG properties that could be animated. 1227451 14 sam 2016-09-07 18:04:43 -0700 (In reply to comment #13) > (In reply to comment #9) > > (In reply to comment #7) > > > > Dictionary is a deprecated type. > > > > > > Could you please clarify - do you mean Dictionary as a class in WebKit? > > > > Yes, Dictionary as a class in WebKit that bridges between JavaScript and DOM > > code is obsolete and should not be used in new code. And that includes the > > Dictionary syntax in IDL. > > If we cannot specify Dictionary on the IDL interface, e.g.: > > Constructor([Default=Undefined] Element? target, sequence<Dictionary> > keyframes) > > Do you have any thoughts on how I should proceed? > > I don’t think defining a dictionary (e.g. dictionary KeyframeInit {…};) is > an option as there are too many CSS and SVG properties that could be > animated. I think we should add support to our generator for half-open dictionaries using something along the lines of the fallowing syntax: [HalfOpenType=(DOMString or sequence<DOMString>)] dictionary BasePropertyIndexedKeyframe { DOMString easing = "linear"; CompositeOperation composite; }; Where you treat it like a dictionary for all the specified types, and the rest of the key/value pairs get processed into a HashMap contained in the struct. 1227505 15 rawinder.webkit 2016-09-07 20:50:24 -0700 Ok. Thanks for the reply - I'll have a look at it(In reply to comment #14) > (In reply to comment #13) > > (In reply to comment #9) > > > (In reply to comment #7) > > > > > Dictionary is a deprecated type. > > > > > > > > Could you please clarify - do you mean Dictionary as a class in WebKit? > > > > > > Yes, Dictionary as a class in WebKit that bridges between JavaScript and DOM > > > code is obsolete and should not be used in new code. And that includes the > > > Dictionary syntax in IDL. > > > > If we cannot specify Dictionary on the IDL interface, e.g.: > > > > Constructor([Default=Undefined] Element? target, sequence<Dictionary> > > keyframes) > > > > Do you have any thoughts on how I should proceed? > > > > I don’t think defining a dictionary (e.g. dictionary KeyframeInit {…};) is > > an option as there are too many CSS and SVG properties that could be > > animated. > > I think we should add support to our generator for half-open dictionaries > using something along the lines of the fallowing syntax: > > [HalfOpenType=(DOMString or sequence<DOMString>)] > dictionary BasePropertyIndexedKeyframe { > DOMString easing = "linear"; > CompositeOperation composite; > }; > > Where you treat it like a dictionary for all the specified types, and the > rest of the key/value pairs get processed into a HashMap contained in the > struct. Okay. Thanks for your reply - I'll have a look at this. 1233918 16 annevk 2016-09-27 10:01:19 -0700 FWIW, Tess pointed me here and I thought I'd point out https://www.w3.org/Bugs/Public/show_bug.cgi?id=20158 which now has discussion about standardizing "half-open dictionaries" in IDL (including "fully open" dictionaries). 1233955 17 darin 2016-09-27 10:38:36 -0700 Given that the timing and frequency property fetching is visible in JavaScript because of the "getters" feature, half-open and open dictionaries are challenging from an interoperability point of view. If there is any difference in order of fetching between user agents it can be a source of incompatibility. 1239705 18 rawinder.webkit 2016-10-12 23:23:17 -0700 This bug has been superseded by Bug #163381 1239706 19 rawinder.webkit 2016-10-12 23:24:03 -0700 *** This bug has been marked as a duplicate of bug 163381 *** 287611 2016-09-01 01:58:15 -0700 2016-09-07 18:05:02 -0700 Patch bug-158509-20160901185509.patch text/plain 8277 rawinder.webkit U3VidmVyc2lvbiBSZXZpc2lvbjogMjA1Mjc5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDFhMzVlNjNjNDQwNmMy NDQxOWYyZjk5ODMzMGI3ZmE4NGUxYjk1MC4uMGRiM2Q2ODBjZTQxNTYyNjgxYjU5NWJiOTYwMmI5 MjU0ODViZGQzMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDE2LTA5LTAxICBSYXdp bmRlciBTaW5naCAgPHJhd2luZGVyLnNpbmdoLXdlYmtpdEBjaXNyYS5jYW5vbi5jb20uYXU+CisK KyAgICAgICAgW1dlYklETF0gQWRkIHN1cHBvcnQgZm9yIHNlcXVlbmNlPERpY3Rpb25hcnk+Cisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNTg1MDkKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgdG9PYmpl Y3RBcnJheSBhbmQgZ2VuZXJhdGUgYmluZGluZyBjb2RlIHRvIGNhbGwgaXQgdG8gcHJvY2VzcyBz ZXF1ZW5jZTxEaWN0aW9uYXJ5PiBmcm9tIElETC4KKworICAgICAgICAqIGJpbmRpbmdzL2pzL0pT RE9NQmluZGluZy5oOgorICAgICAgICAoV2ViQ29yZTo6dG9PYmplY3RBcnJheSk6CisgICAgICAg ICogYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9yLnBtOgorICAgICAgICAoSXNSZWZQdHJU eXBlKToKKyAgICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JKUy5wbToKKyAg ICAgICAgKEpTVmFsdWVUb05hdGl2ZSk6CisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0cy90ZXN0 L0pTL0pTVGVzdE9iai5jcHA6CisgICAgICAgIChXZWJDb3JlOjpqc1Rlc3RPYmpQcm90b3R5cGVG dW5jdGlvbk1ldGhvZFdpdGhEaWN0aW9uYXJ5U2VxdWVuY2UpOgorICAgICAgICAqIGJpbmRpbmdz L3NjcmlwdHMvdGVzdC9UZXN0T2JqLmlkbDoKKwogMjAxNi0wOC0zMSAgWXVzdWtlIFN1enVraSAg PHV0YXRhbmUudGVhQGdtYWlsLmNvbT4KIAogICAgICAgICBbSlNDXSBBZGQgaW5pdGlhdG9yIHBh cmFtZXRlciB0byBtb2R1bGUgcGlwZWxpbmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0pTRE9NQmluZGluZy5oIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNE T01CaW5kaW5nLmgKaW5kZXggZDQxNmI2MDJjYmFhYTA2ZTc2ZTYzOWNhOGJhZTE3MzRjNjE0OWNl Yi4uNjE1NDk4MTU4M2JlZjEyZDViYjc1NWMyYzA2MzQ5MTUxNWMwNzc2NCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNET01CaW5kaW5nLmgKKysrIGIvU291cmNlL1dl YkNvcmUvYmluZGluZ3MvanMvSlNET01CaW5kaW5nLmgKQEAgLTc2Miw2ICs3NjIsMTkgQEAgdGVt cGxhdGU8dHlwZW5hbWUgVD4gVmVjdG9yPFQ+IHRvTmF0aXZlQXJyYXkoSlNDOjpFeGVjU3RhdGUm IGV4ZWMsIEpTQzo6SlNWYWx1ZQogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKK3RlbXBsYXRlPHR5 cGVuYW1lIFQ+IFZlY3RvcjxUPiB0b09iamVjdEFycmF5KEpTQzo6RXhlY1N0YXRlJiBleGVjLCBK U0M6OkpTVmFsdWUgdmFsdWUpCit7CisgICAgaWYgKCF2YWx1ZS5pc09iamVjdCgpKQorICAgICAg ICByZXR1cm4gVmVjdG9yPFQ+KCk7CisKKyAgICBWZWN0b3I8VD4gcmVzdWx0OworICAgIGZvckVh Y2hJbkl0ZXJhYmxlKCZleGVjLCB2YWx1ZSwgWyZyZXN1bHRdKEpTQzo6Vk0mLCBKU0M6OkV4ZWNT dGF0ZSogc3RhdGUsIEpTQzo6SlNWYWx1ZSBqc1ZhbHVlKSB7CisgICAgICAgIHJlc3VsdC5hcHBl bmQoVChzdGF0ZSwganNWYWx1ZSkpOworICAgICAgICBBU1NFUlQoIXN0YXRlLT5oYWRFeGNlcHRp b24oKSk7CisgICAgfSk7CisgICAgcmV0dXJuIHJlc3VsdDsKK30KKwogdGVtcGxhdGU8dHlwZW5h bWUgVD4gVmVjdG9yPFQ+IHRvTmF0aXZlQXJndW1lbnRzKEpTQzo6RXhlY1N0YXRlJiBleGVjLCBz aXplX3Qgc3RhcnRJbmRleCkKIHsKICAgICBzaXplX3QgbGVuZ3RoID0gZXhlYy5hcmd1bWVudENv dW50KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVH ZW5lcmF0b3IucG0gYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0 b3IucG0KaW5kZXggMzFiZTcxMWE0YTUxMjIzZjFiZjRkMzkwMjQ1ZTZiMmQzNTM3ODc3Zi4uYTAx NWZhMDdkMWE2Y2YzMzNkMjJiNGQ4ODAwNGE2ZjM4NjgxYmRmZSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9yLnBtCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvQ29kZUdlbmVyYXRvci5wbQpAQCAtNTE1LDYgKzUxNSw3 IEBAIHN1YiBJc1JlZlB0clR5cGUKICAgICByZXR1cm4gMCBpZiAkb2JqZWN0LT5Jc0RpY3Rpb25h cnlUeXBlKCR0eXBlKTsKICAgICByZXR1cm4gMCBpZiAkb2JqZWN0LT5Jc0VudW1UeXBlKCR0eXBl KTsKICAgICByZXR1cm4gMCBpZiAkb2JqZWN0LT5Jc1NlcXVlbmNlT3JGcm96ZW5BcnJheVR5cGUo JHR5cGUpOworICAgIHJldHVybiAwIGlmICR0eXBlIGVxICJEaWN0aW9uYXJ5IjsKICAgICByZXR1 cm4gMCBpZiAkdHlwZSBlcSAiRE9NU3RyaW5nIiBvciAkdHlwZSBlcSAiVVNWU3RyaW5nIjsKICAg ICByZXR1cm4gMCBpZiAkdHlwZSBlcSAiYW55IjsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9ySlMucG0gYi9Tb3VyY2UvV2ViQ29yZS9i aW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JKUy5wbQppbmRleCA2ZTBiYTdiMGY5NGNjOTE0 MDg0YjZiMTQ1NTZiNDk5ZWU0ZTMwNmFmLi4zMmQxOTQ1NGI2YTYxMGNlZTZlNDc2Nzk5NDFiYTk2 MTY3NzhmYTI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL0Nv ZGVHZW5lcmF0b3JKUy5wbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL0Nv ZGVHZW5lcmF0b3JKUy5wbQpAQCAtNDc0NCw2ICs0NzQ0LDEwIEBAIHN1YiBKU1ZhbHVlVG9OYXRp dmUKICAgICAgICAgaWYgKCRjb2RlR2VuZXJhdG9yLT5Jc1JlZlB0clR5cGUoJGlubmVyVHlwZSkp IHsKICAgICAgICAgICAgIEFkZFRvSW1wbEluY2x1ZGVzKCJKUyR7aW5uZXJUeXBlfS5oIik7CiAg ICAgICAgICAgICByZXR1cm4gKCJ0b1JlZlB0ck5hdGl2ZUFycmF5PCR7aW5uZXJUeXBlfSwgSlMk e2lubmVyVHlwZX0+KCpzdGF0ZSwgJHZhbHVlKSIsIDEpOworICAgICAgICB9IGVsc2lmICgkaW5u ZXJUeXBlIGVxICJEaWN0aW9uYXJ5IikgeworICAgICAgICAgICAgQWRkVG9JbXBsSW5jbHVkZXMo IkRpY3Rpb25hcnkuaCIsICRjb25kaXRpb25hbCk7CisgICAgICAgICAgICBBZGRUb0ltcGxJbmNs dWRlcygiSlMke2lubmVyVHlwZX0uaCIsICRjb25kaXRpb25hbCk7CisgICAgICAgICAgICByZXR1 cm4gKCJ0b09iamVjdEFycmF5PCIgLiBHZXROYXRpdmVWZWN0b3JJbm5lclR5cGUoJGlubmVyVHlw ZSkgLiAiPigqc3RhdGUsICR2YWx1ZSkiLCAxKTsKICAgICAgICAgfQogICAgICAgICByZXR1cm4g KCJ0b05hdGl2ZUFycmF5PCIgLiBHZXROYXRpdmVWZWN0b3JJbm5lclR5cGUoJGlubmVyVHlwZSkg LiAiPigqc3RhdGUsICR2YWx1ZSkiLCAxKTsKICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMvSlNUZXN0T2JqLmNwcCBiL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RPYmouY3BwCmluZGV4IDI1NWM5MTcy ZmE4NTVjZjA4MDAwZTA1Zjk1YzI5Mjk4YzkxNjQyN2UuLjMwYjA5M2JkMjJjNjQxZmMwMjgxYjgw N2Y0MmVlMWE4NDQ1NDc2MzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Nj cmlwdHMvdGVzdC9KUy9KU1Rlc3RPYmouY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RPYmouY3BwCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVk ZSAiSlNET01JdGVyYXRvci5oIgogI2luY2x1ZGUgIkpTRE9NUHJvbWlzZS5oIgogI2luY2x1ZGUg IkpTRE9NU3RyaW5nTGlzdC5oIgorI2luY2x1ZGUgIkpTRGljdGlvbmFyeS5oIgogI2luY2x1ZGUg IkpTRG9jdW1lbnQuaCIKICNpbmNsdWRlICJKU0VsZW1lbnQuaCIKICNpbmNsdWRlICJKU0V2ZW50 TGlzdGVuZXIuaCIKQEAgLTc4Niw2ICs3ODcsNyBAQCBKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19I T1NUX0NBTEwganNUZXN0T2JqQ29uc3RydWN0b3JGdW5jdGlvbk92ZXJsb2FkZWRNZXRob2QxKAog SlNDOjpFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGpzVGVzdE9ialByb3RvdHlwZUZ1bmN0 aW9uQ2xhc3NNZXRob2RXaXRoQ2xhbXAoSlNDOjpFeGVjU3RhdGUqKTsKIEpTQzo6RW5jb2RlZEpT VmFsdWUgSlNDX0hPU1RfQ0FMTCBqc1Rlc3RPYmpQcm90b3R5cGVGdW5jdGlvbkNsYXNzTWV0aG9k V2l0aEVuZm9yY2VSYW5nZShKU0M6OkV4ZWNTdGF0ZSopOwogSlNDOjpFbmNvZGVkSlNWYWx1ZSBK U0NfSE9TVF9DQUxMIGpzVGVzdE9ialByb3RvdHlwZUZ1bmN0aW9uTWV0aG9kV2l0aFVuc2lnbmVk TG9uZ1NlcXVlbmNlKEpTQzo6RXhlY1N0YXRlKik7CitKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19I T1NUX0NBTEwganNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25NZXRob2RXaXRoRGljdGlvbmFyeVNl cXVlbmNlKEpTQzo6RXhlY1N0YXRlKik7CiBKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NB TEwganNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25TdHJpbmdBcnJheUZ1bmN0aW9uKEpTQzo6RXhl Y1N0YXRlKik7CiBKU0M6OkVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqUHJv dG90eXBlRnVuY3Rpb25Eb21TdHJpbmdMaXN0RnVuY3Rpb24oSlNDOjpFeGVjU3RhdGUqKTsKIEpT Qzo6RW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBqc1Rlc3RPYmpQcm90b3R5cGVGdW5jdGlv bk1ldGhvZFdpdGhBbmRXaXRob3V0TnVsbGFibGVTZXF1ZW5jZShKU0M6OkV4ZWNTdGF0ZSopOwpA QCAtMTM5MCw2ICsxMzkyLDcgQEAgc3RhdGljIGNvbnN0IEhhc2hUYWJsZVZhbHVlIEpTVGVzdE9i alByb3RvdHlwZVRhYmxlVmFsdWVzW10gPQogICAgIHsgImNsYXNzTWV0aG9kV2l0aENsYW1wIiwg SlNDOjpGdW5jdGlvbiwgTm9JbnRyaW5zaWMsIHsgKGludHB0cl90KXN0YXRpY19jYXN0PE5hdGl2 ZUZ1bmN0aW9uPihqc1Rlc3RPYmpQcm90b3R5cGVGdW5jdGlvbkNsYXNzTWV0aG9kV2l0aENsYW1w KSwgKGludHB0cl90KSAoMikgfSB9LAogICAgIHsgImNsYXNzTWV0aG9kV2l0aEVuZm9yY2VSYW5n ZSIsIEpTQzo6RnVuY3Rpb24sIE5vSW50cmluc2ljLCB7IChpbnRwdHJfdClzdGF0aWNfY2FzdDxO YXRpdmVGdW5jdGlvbj4oanNUZXN0T2JqUHJvdG90eXBlRnVuY3Rpb25DbGFzc01ldGhvZFdpdGhF bmZvcmNlUmFuZ2UpLCAoaW50cHRyX3QpICgyKSB9IH0sCiAgICAgeyAibWV0aG9kV2l0aFVuc2ln bmVkTG9uZ1NlcXVlbmNlIiwgSlNDOjpGdW5jdGlvbiwgTm9JbnRyaW5zaWMsIHsgKGludHB0cl90 KXN0YXRpY19jYXN0PE5hdGl2ZUZ1bmN0aW9uPihqc1Rlc3RPYmpQcm90b3R5cGVGdW5jdGlvbk1l dGhvZFdpdGhVbnNpZ25lZExvbmdTZXF1ZW5jZSksIChpbnRwdHJfdCkgKDEpIH0gfSwKKyAgICB7 ICJtZXRob2RXaXRoRGljdGlvbmFyeVNlcXVlbmNlIiwgSlNDOjpGdW5jdGlvbiwgTm9JbnRyaW5z aWMsIHsgKGludHB0cl90KXN0YXRpY19jYXN0PE5hdGl2ZUZ1bmN0aW9uPihqc1Rlc3RPYmpQcm90 b3R5cGVGdW5jdGlvbk1ldGhvZFdpdGhEaWN0aW9uYXJ5U2VxdWVuY2UpLCAoaW50cHRyX3QpICgx KSB9IH0sCiAgICAgeyAic3RyaW5nQXJyYXlGdW5jdGlvbiIsIEpTQzo6RnVuY3Rpb24sIE5vSW50 cmluc2ljLCB7IChpbnRwdHJfdClzdGF0aWNfY2FzdDxOYXRpdmVGdW5jdGlvbj4oanNUZXN0T2Jq UHJvdG90eXBlRnVuY3Rpb25TdHJpbmdBcnJheUZ1bmN0aW9uKSwgKGludHB0cl90KSAoMSkgfSB9 LAogICAgIHsgImRvbVN0cmluZ0xpc3RGdW5jdGlvbiIsIEpTQzo6RnVuY3Rpb24sIE5vSW50cmlu c2ljLCB7IChpbnRwdHJfdClzdGF0aWNfY2FzdDxOYXRpdmVGdW5jdGlvbj4oanNUZXN0T2JqUHJv dG90eXBlRnVuY3Rpb25Eb21TdHJpbmdMaXN0RnVuY3Rpb24pLCAoaW50cHRyX3QpICgxKSB9IH0s CiAgICAgeyAibWV0aG9kV2l0aEFuZFdpdGhvdXROdWxsYWJsZVNlcXVlbmNlIiwgSlNDOjpGdW5j dGlvbiwgTm9JbnRyaW5zaWMsIHsgKGludHB0cl90KXN0YXRpY19jYXN0PE5hdGl2ZUZ1bmN0aW9u Pihqc1Rlc3RPYmpQcm90b3R5cGVGdW5jdGlvbk1ldGhvZFdpdGhBbmRXaXRob3V0TnVsbGFibGVT ZXF1ZW5jZSksIChpbnRwdHJfdCkgKDIpIH0gfSwKQEAgLTY3NjEsNiArNjc2NCwyMyBAQCBFbmNv ZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGpzVGVzdE9ialByb3RvdHlwZUZ1bmN0aW9uTWV0aG9k V2l0aFVuc2lnbmVkTG9uZ1NlcQogICAgIHJldHVybiBKU1ZhbHVlOjplbmNvZGUoanNVbmRlZmlu ZWQoKSk7CiB9CiAKK0VuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwganNUZXN0T2JqUHJvdG90 eXBlRnVuY3Rpb25NZXRob2RXaXRoRGljdGlvbmFyeVNlcXVlbmNlKEV4ZWNTdGF0ZSogc3RhdGUp Cit7CisgICAgSlNWYWx1ZSB0aGlzVmFsdWUgPSBzdGF0ZS0+dGhpc1ZhbHVlKCk7CisgICAgYXV0 byBjYXN0ZWRUaGlzID0ganNEeW5hbWljQ2FzdDxKU1Rlc3RPYmoqPih0aGlzVmFsdWUpOworICAg IGlmIChVTkxJS0VMWSghY2FzdGVkVGhpcykpCisgICAgICAgIHJldHVybiB0aHJvd1RoaXNUeXBl RXJyb3IoKnN0YXRlLCAiVGVzdE9iamVjdCIsICJtZXRob2RXaXRoRGljdGlvbmFyeVNlcXVlbmNl Iik7CisgICAgQVNTRVJUX0dDX09CSkVDVF9JTkhFUklUUyhjYXN0ZWRUaGlzLCBKU1Rlc3RPYmo6 OmluZm8oKSk7CisgICAgYXV0byYgaW1wbCA9IGNhc3RlZFRoaXMtPndyYXBwZWQoKTsKKyAgICBp ZiAoVU5MSUtFTFkoc3RhdGUtPmFyZ3VtZW50Q291bnQoKSA8IDEpKQorICAgICAgICByZXR1cm4g dGhyb3dWTUVycm9yKHN0YXRlLCBjcmVhdGVOb3RFbm91Z2hBcmd1bWVudHNFcnJvcihzdGF0ZSkp OworICAgIGF1dG8gZGljdGlvbmFyeSA9IHRvT2JqZWN0QXJyYXk8RGljdGlvbmFyeT4oKnN0YXRl LCBzdGF0ZS0+YXJndW1lbnQoMCkpOworICAgIGlmIChVTkxJS0VMWShzdGF0ZS0+aGFkRXhjZXB0 aW9uKCkpKQorICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKGpzVW5kZWZpbmVkKCkpOwor ICAgIGltcGwubWV0aG9kV2l0aERpY3Rpb25hcnlTZXF1ZW5jZShXVEZNb3ZlKGRpY3Rpb25hcnkp KTsKKyAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKGpzVW5kZWZpbmVkKCkpOworfQorCiBFbmNv ZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGpzVGVzdE9ialByb3RvdHlwZUZ1bmN0aW9uU3RyaW5n QXJyYXlGdW5jdGlvbihFeGVjU3RhdGUqIHN0YXRlKQogewogICAgIFZNJiB2bSA9IHN0YXRlLT52 bSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L1Rl c3RPYmouaWRsIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L1Rlc3RPYmou aWRsCmluZGV4IDc2NzZiZGNkNzQzZGMyZmEzY2U2OTE4MjI0NjBiMWRjZTdhMTQ1OWQuLjQ5YmU1 YWVmMjJhOGY5ZTE1Mjk3NjYyNDYwZTY1MmUwMGMwODlmZjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9UZXN0T2JqLmlkbAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvVGVzdE9iai5pZGwKQEAgLTMxMSw2ICszMTEsNyBA QCBlbnVtIFRlc3RDb25maWRlbmNlIHsgImhpZ2giLCAia2luZGEtbG93IiB9OwogCiAjaWYgZGVm aW5lZChURVNUSU5HX0pTKQogICAgIHZvaWQgbWV0aG9kV2l0aFVuc2lnbmVkTG9uZ1NlcXVlbmNl KHNlcXVlbmNlPHVuc2lnbmVkIGxvbmc+IHVuc2lnbmVkTG9uZ1NlcXVlbmNlKTsKKyAgICB2b2lk IG1ldGhvZFdpdGhEaWN0aW9uYXJ5U2VxdWVuY2Uoc2VxdWVuY2U8RGljdGlvbmFyeT4gZGljdGlv bmFyeSk7CiAgICAgW1JhaXNlc0V4Y2VwdGlvbl0gc2VxdWVuY2U8RE9NU3RyaW5nPiBzdHJpbmdB cnJheUZ1bmN0aW9uKHNlcXVlbmNlPERPTVN0cmluZz4gdmFsdWVzKTsKICAgICBbUmFpc2VzRXhj ZXB0aW9uXSBET01TdHJpbmdMaXN0IGRvbVN0cmluZ0xpc3RGdW5jdGlvbihET01TdHJpbmdMaXN0 IHZhbHVlcyk7CiAK