70015 2011-10-13 04:06:19 -0700 Constructor should not be called if the object is being constructed inside WebCore 2011-10-18 21:52:17 -0700 1 1 1 Unclassified WebKit DOM 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 0 haraken webkit-unassigned abarth annacc dominicc morrita webkit.review.bot oldest_to_newest 483107 0 haraken 2011-10-13 04:06:19 -0700 Summary: A DOM object can be created from the JS context and from the WebCore context. Constructor should be called if the object is created from the JS context, but should not be called if the object is created from the WebCore context. Details: - Expected behavior when the object is created from the JS context (e.g. "new Event()"): (1) V8XXXX::constructorCallback() is called. (2) V8XXXX::constructorCallback() calls XXXX::create(). (3) XXXX::create() creates a C++ object. (4) V8XXXX::constructorCallback() calls toV8() for the C++ object. (5) toV8() wraps the C++ object and returns the wrapped JS object. - Actual behavior when the object is created from the JS context (e.g. "new Event()"): As described above (1) - (5). That's fine!! - Expected behavior when the object is created from the WebCore context. (e.g. "window.addEventListener("load", function (event) { ... });". In this case, the Event object is created inside the WebCore context): (1) WebCore calls XXXX::create(). (2) XXXX::create() creates a C++ object. (3) WebCore calls toV8() for the C++ object. (4) toV8() wraps the C++ object and returns the wrapped JS object. - Actual behavior when the object is created from the WebCore context. (e.g. "window.addEventListener("load", function (event) { ... });"): (1) WebCore calls XXXX::create(). (2) XXXX::create() creates a C++ object. (3) WebCore calls toV8() for the C++ object. (4) toV8() can call XXXX::constructorCallback(). (Whether or not toV8() calls XXXX::constructorCallback() depends on the implementation of toV8().) (5) V8XXXX::constructorCallback() calls XXXX::create(). (6) XXXX::create() creates __another__ C++ object. (7) V8XXXX::constructorCallback() calls toV8() for the C++ object. (8) toV8() wraps the C++ object and returns the wrapped JS object. This actual behavior definitely causes the following problems: - Problem1: The object returned to JS is not the object created in (2) but the object created in (6). However, I do not yet know a test case that causes some visible bug because of this problem. - Problem2: In (4), XXXX::constructorCallback() can be called with no argument. If XXXX::constructorCallback() expects at least one argument, XXXX::constructorCallback() throws TypeError, resulting in crash. For example, Event caused this problem when I implemented constructor for Event. Based on the discussion with Dominicc, we solved this problem by adding the following two lines of code to Event::constructorCallback() (See here: http://codesearch.google.com/codesearch#OAMlx_jo-ck/src/third_party/WebKit/Source/WebCore/bindings/v8/custom/V8EventConstructors.cpp&exact_package=chromium&q=allowallocation&type=cs): XXXX::constructorCallback(...) { ...; if (AllowAllocation::current()) return args.Holder(); ...; } This if check means "XXXX::constructorCallback() returns immediately if it is called from the WebCore context". With these observations, we think that all constructorCallback() should have the above if check. This patch adds the if check to CodeGeneratorV8.pm. After this patch is landed, I would like to add the if check to all existing custom V8 constructors. 483113 1 110823 haraken 2011-10-13 04:21:09 -0700 Created attachment 110823 Patch 483327 2 110823 abarth 2011-10-13 11:08:44 -0700 Comment on attachment 110823 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=110823&action=review > Source/WebCore/bindings/scripts/CodeGeneratorV8.pm:1536 > + if (AllowAllocation::current()) > + return args.Holder(); Do we need this check in any of our custom constructors as well? I don't fully understand in which cases AllowAllocation::current() return true. 483632 3 110823 webkit.review.bot 2011-10-13 16:38:22 -0700 Comment on attachment 110823 Patch Clearing flags on attachment: 110823 Committed r97423: <http://trac.webkit.org/changeset/97423> 483633 4 webkit.review.bot 2011-10-13 16:38:27 -0700 All reviewed patches have been landed. Closing bug. 483687 5 haraken 2011-10-13 17:48:27 -0700 (In reply to comment #2) > (From update of attachment 110823 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=110823&action=review > > > Source/WebCore/bindings/scripts/CodeGeneratorV8.pm:1536 > > + if (AllowAllocation::current()) > > + return args.Holder(); > > Do we need this check in any of our custom constructors as well? I don't fully understand in which cases AllowAllocation::current() return true. Adam: AllowAllocation::current() just calls Isolate::GetCurrent(), and Isolate::GetCurrent() returns the entered isolate for the current thread or NULL in case there is no current isolate (See the comment of Isolate::GetCurrent(): http://codesearch.google.com/codesearch#OAMlx_jo-ck/src/v8/include/v8.h&type=cs&l=2727). In my understanding, this means that AllowAllocation::current() returns true if it is called inside toV8() which is invoked from the WebCore context, which is the case where constructorCallback() should not be executed. This patch added the AllowAllocation check to all non-custom constructors of V8. I think that the AllowAllocation check should be also in all custom constructors of V8. Indeed, as for existing custom constructors, no bugs have been occurring without the AllowAllocation check. However, (1) the Problem1 and Problem2 that I described above can happen in the future if someone changes code, and (2) if the AllowAllocation check does not exist in the existing custom constructors, people will add a new custom constructor without the AllowAllocation check without considering the possibility of Problem1 and Problem2, which may result in ugly bugs. WDYT? 483695 6 abarth 2011-10-13 18:09:15 -0700 Checking that static information isn't correct in all cases. For example, sometimes we run WebCore code with JavaScript on the static and sometimes we run WebCore code without JavaScript on the stack. Have the constructors work differently in those cases isn't really correct. I'd feel a lot better about all of this if we could write tests to exercise the differences. 483822 7 haraken 2011-10-14 00:38:29 -0700 (In reply to comment #6) > Checking that static information isn't correct in all cases. For example, sometimes we run WebCore code with JavaScript on the static and sometimes we run WebCore code without JavaScript on the stack. Have the constructors work differently in those cases isn't really correct. > Adam: Thank you very much. I will investigate more to find a correct way to make constructorCallback() to be called only when constructorCallback() should be called. 483823 8 abarth 2011-10-14 00:51:35 -0700 Thanks. I wouldn't get overly fixated on this problem, but it would be good to sort out. 483916 9 dominicc 2011-10-14 05:14:02 -0700 (in reply to comment #5): > Adam: AllowAllocation::current() just calls Isolate::GetCurrent(), and Isolate::GetCurrent() returns the > entered isolate for the current thread or NULL in case there is no current isolate (See the comment of > Isolate::GetCurrent(): http://codesearch.google.com/codesearch#OAMlx_jo- > ck/src/v8/include/v8.h&type=cs&l=2727). In my understanding, this means that > AllowAllocation::current() returns true if it is called inside toV8() which is invoked from the WebCore > context, which is the case where constructorCallback() should not be executed. This is not quite right. One thing that makes this confusing is that the name ”AllowAllocation” is not a good name any more. Let me try to explain: As described in the description, V8 calls C++ constructor callbacks in two situations: 1. The author allocates an instance via "new X"; X is a function with a C++ construct callback. 2. C++ allocates an instance via the function template. Typical DOM constructor functions disallow the first way—they throw. AllowAllocation is an RAII guard. When the bindings are doing number two (ugh… that sounds bad…) it puts an AllowAllocation on the stack, the callback runs and checks the guard (this is _all_ the typical DOM constructor callback does—it is V8Proxy::checkNewLegal.) The guard is not just "is an isolate/V8 context present." It is, _are "allocations allowed"_ in the current isolate. A boolean that is set and restored by RAII ctor and dtor. So you can see why AllowAllocations is no longer an appropriate name. Because method 1—the author allocates via "new X"—works, the allocation should be "allowed." But the C++ callback needs to discern when it is invoked by the author, and should allocate the C++ object to wrap, or when it is invoked by the wrapper table which will hand it a pointer to wrap. 484077 10 abarth 2011-10-14 11:14:03 -0700 Ah, that makes sense. Can we re-name AllowAllocations to make this more obvious. 486555 11 haraken 2011-10-18 21:52:17 -0700 (In reply to comment #10) > Ah, that makes sense. Can we re-name AllowAllocations to make this more obvious. OK, I will fix it in the bug 70397. 110823 2011-10-13 04:21:09 -0700 2011-10-13 16:38:22 -0700 Patch bug-70015-20111013202107.patch text/plain 7024 haraken U3VidmVyc2lvbiBSZXZpc2lvbjogOTczMjUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBjMDM5Y2MxZDI1OTI4YjIz ZjBkMjE2YmEwNDU2Zjc1MDgwYWI4YWViLi5hM2NiMTdjOGFjNjkxMGMwNWVhZjdkODhkNGFkZjA5 MzhkMmZiMmU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsODEgQEAKKzIwMTEtMTAtMTMgIEtlbnRh cm8gSGFyYSAgPGhhcmFrZW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIENvbnN0cnVjdG9yIHNo b3VsZCBub3QgYmUgY2FsbGVkIGlmIHRoZSBvYmplY3QgaXMgYmVpbmcgY29uc3RydWN0ZWQgaW5z aWRlIFdlYkNvcmUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTcwMDE1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgU3VtbWFyeTogQSBET00gb2JqZWN0IGNhbiBiZSBjcmVhdGVkIGZyb20gdGhlIEpTIGNvbnRl eHQgYW5kIGZyb20gdGhlIFdlYkNvcmUgY29udGV4dC4KKyAgICAgICAgQ29uc3RydWN0b3Igc2hv dWxkIGJlIGNhbGxlZCBpZiB0aGUgb2JqZWN0IGlzIGNyZWF0ZWQgZnJvbSB0aGUgSlMgY29udGV4 dCwKKyAgICAgICAgYnV0IHNob3VsZCBub3QgYmUgY2FsbGVkIGlmIHRoZSBvYmplY3QgaXMgY3Jl YXRlZCBmcm9tIHRoZSBXZWJDb3JlIGNvbnRleHQuCisKKyAgICAgICAgRGV0YWlsczoKKyAgICAg ICAgLSBFeHBlY3RlZCBiZWhhdmlvciB3aGVuIHRoZSBvYmplY3QgaXMgY3JlYXRlZCBmcm9tIHRo ZSBKUyBjb250ZXh0IChlLmcuICJuZXcgRXZlbnQoKSIpOgorICAgICAgICAoMSkgVjhYWFhYOjpj b25zdHJ1Y3RvckNhbGxiYWNrKCkgaXMgY2FsbGVkLgorICAgICAgICAoMikgVjhYWFhYOjpjb25z dHJ1Y3RvckNhbGxiYWNrKCkgY2FsbHMgWFhYWDo6Y3JlYXRlKCkuCisgICAgICAgICgzKSBYWFhY OjpjcmVhdGUoKSBjcmVhdGVzIGEgQysrIG9iamVjdC4KKyAgICAgICAgKDQpIFY4WFhYWDo6Y29u c3RydWN0b3JDYWxsYmFjaygpIGNhbGxzIHRvVjgoKSBmb3IgdGhlIEMrKyBvYmplY3QuCisgICAg ICAgICg1KSB0b1Y4KCkgd3JhcHMgdGhlIEMrKyBvYmplY3QgYW5kIHJldHVybnMgdGhlIHdyYXBw ZWQgSlMgb2JqZWN0LgorCisgICAgICAgIC0gQWN0dWFsIGJlaGF2aW9yIHdoZW4gdGhlIG9iamVj dCBpcyBjcmVhdGVkIGZyb20gdGhlIEpTIGNvbnRleHQgKGUuZy4gIm5ldyBFdmVudCgpIik6Cisg ICAgICAgIEFzIGRlc2NyaWJlZCBhYm92ZSAoMSkgLSAoNSkuIFRoYXQncyBmaW5lISEKKworICAg ICAgICAtIEV4cGVjdGVkIGJlaGF2aW9yIHdoZW4gdGhlIG9iamVjdCBpcyBjcmVhdGVkIGZyb20g dGhlIFdlYkNvcmUgY29udGV4dC4KKyAgICAgICAgKGUuZy4gIndpbmRvdy5hZGRFdmVudExpc3Rl bmVyKCJsb2FkIiwgZnVuY3Rpb24gKGV2ZW50KSB7IC4uLiB9KTsiLiBJbiB0aGlzIGNhc2UsCisg ICAgICAgIHRoZSBFdmVudCBvYmplY3QgaXMgY3JlYXRlZCBpbnNpZGUgdGhlIFdlYkNvcmUgY29u dGV4dCk6CisgICAgICAgICgxKSBXZWJDb3JlIGNhbGxzIFhYWFg6OmNyZWF0ZSgpLgorICAgICAg ICAoMikgWFhYWDo6Y3JlYXRlKCkgY3JlYXRlcyBhIEMrKyBvYmplY3QuCisgICAgICAgICgzKSBX ZWJDb3JlIGNhbGxzIHRvVjgoKSBmb3IgdGhlIEMrKyBvYmplY3QuCisgICAgICAgICg0KSB0b1Y4 KCkgd3JhcHMgdGhlIEMrKyBvYmplY3QgYW5kIHJldHVybnMgdGhlIHdyYXBwZWQgSlMgb2JqZWN0 LgorCisgICAgICAgIC0gQWN0dWFsIGJlaGF2aW9yIHdoZW4gdGhlIG9iamVjdCBpcyBjcmVhdGVk IGZyb20gdGhlIFdlYkNvcmUgY29udGV4dC4KKyAgICAgICAgKGUuZy4gIndpbmRvdy5hZGRFdmVu dExpc3RlbmVyKCJsb2FkIiwgZnVuY3Rpb24gKGV2ZW50KSB7IC4uLiB9KTsiKToKKyAgICAgICAg KDEpIFdlYkNvcmUgY2FsbHMgWFhYWDo6Y3JlYXRlKCkuCisgICAgICAgICgyKSBYWFhYOjpjcmVh dGUoKSBjcmVhdGVzIGEgQysrIG9iamVjdC4KKyAgICAgICAgKDMpIFdlYkNvcmUgY2FsbHMgdG9W OCgpIGZvciB0aGUgQysrIG9iamVjdC4KKyAgICAgICAgKDQpIHRvVjgoKSBjYW4gY2FsbCBYWFhY Ojpjb25zdHJ1Y3RvckNhbGxiYWNrKCkuIChXaGV0aGVyIG9yIG5vdCB0b1Y4KCkgY2FsbHMKKyAg ICAgICAgWFhYWDo6Y29uc3RydWN0b3JDYWxsYmFjaygpIGRlcGVuZHMgb24gdGhlIGltcGxlbWVu dGF0aW9uIG9mIHRvVjgoKS4pCisgICAgICAgICg1KSBWOFhYWFg6OmNvbnN0cnVjdG9yQ2FsbGJh Y2soKSBjYWxscyBYWFhYOjpjcmVhdGUoKS4KKyAgICAgICAgKDYpIFhYWFg6OmNyZWF0ZSgpIGNy ZWF0ZXMgX19hbm90aGVyX18gQysrIG9iamVjdC4KKyAgICAgICAgKDcpIFY4WFhYWDo6Y29uc3Ry dWN0b3JDYWxsYmFjaygpIGNhbGxzIHRvVjgoKSBmb3IgdGhlIEMrKyBvYmplY3QuCisgICAgICAg ICg4KSB0b1Y4KCkgd3JhcHMgdGhlIEMrKyBvYmplY3QgYW5kIHJldHVybnMgdGhlIHdyYXBwZWQg SlMgb2JqZWN0LgorCisgICAgICAgIFRoaXMgYWN0dWFsIGJlaGF2aW9yIGRlZmluaXRlbHkgY2F1 c2VzIHRoZSBmb2xsb3dpbmcgcHJvYmxlbXM6CisKKyAgICAgICAgLSBQcm9ibGVtMTogVGhlIG9i amVjdCByZXR1cm5lZCB0byBKUyBpcyBub3QgdGhlIG9iamVjdCBjcmVhdGVkIGluICgyKQorICAg ICAgICBidXQgdGhlIG9iamVjdCBjcmVhdGVkIGluICg2KS4gSG93ZXZlciwgSSBkbyBub3QgeWV0 IGtub3cgYSB0ZXN0IGNhc2UgdGhhdCBjYXVzZXMKKyAgICAgICAgc29tZSB2aXNpYmxlIGJ1ZyBi ZWNhdXNlIG9mIHRoaXMgcHJvYmxlbS4KKworICAgICAgICAtIFByb2JsZW0yOiBJbiAoNCksIFhY WFg6OmNvbnN0cnVjdG9yQ2FsbGJhY2soKSBjYW4gYmUgY2FsbGVkIHdpdGggbm8gYXJndW1lbnQu CisgICAgICAgIElmIFhYWFg6OmNvbnN0cnVjdG9yQ2FsbGJhY2soKSBleHBlY3RzIGF0IGxlYXN0 IG9uZSBhcmd1bWVudCwgWFhYWDo6Y29uc3RydWN0b3JDYWxsYmFjaygpCisgICAgICAgIHRocm93 cyBUeXBlRXJyb3IsIHJlc3VsdGluZyBpbiBjcmFzaC4gRm9yIGV4YW1wbGUsIEV2ZW50IGNhdXNl ZCB0aGlzIHByb2JsZW0KKyAgICAgICAgd2hlbiBJIGltcGxlbWVudGVkIGNvbnN0cnVjdG9yIGZv ciBFdmVudC4gQmFzZWQgb24gdGhlIGRpc2N1c3Npb24gd2l0aCBEb21pbmljYywKKyAgICAgICAg d2Ugc29sdmVkIHRoaXMgcHJvYmxlbSBieSBhZGRpbmcgdGhlIGZvbGxvd2luZyB0d28gbGluZXMg b2YgY29kZSB0byBFdmVudDo6Y29uc3RydWN0b3JDYWxsYmFjaygpCisgICAgICAgIChTZWUgaGVy ZTogaHR0cDovL2NvZGVzZWFyY2guZ29vZ2xlLmNvbS9jb2Rlc2VhcmNoI09BTWx4X2pvLWNrL3Ny Yy90aGlyZF9wYXJ0eS9XZWJLaXQvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4 RXZlbnRDb25zdHJ1Y3RvcnMuY3BwJmV4YWN0X3BhY2thZ2U9Y2hyb21pdW0mcT1hbGxvd2FsbG9j YXRpb24mdHlwZT1jcyk6CisKKyAgICAgICAgWFhYWDo6Y29uc3RydWN0b3JDYWxsYmFjayguLi4p IHsKKyAgICAgICAgICAgIC4uLjsKKyAgICAgICAgICAgIGlmIChBbGxvd0FsbG9jYXRpb246OmN1 cnJlbnQoKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gYXJncy5Ib2xkZXIoKTsKKyAgICAgICAg ICAgIC4uLjsKKyAgICAgICAgfQorCisgICAgICAgIFRoaXMgaWYgY2hlY2sgbWVhbnMgIlhYWFg6 OmNvbnN0cnVjdG9yQ2FsbGJhY2soKSByZXR1cm5zIGltbWVkaWF0ZWx5IGlmIGl0IGlzIGNhbGxl ZAorICAgICAgICBmcm9tIHRoZSBXZWJDb3JlIGNvbnRleHQiLgorCisgICAgICAgIFdpdGggdGhl c2Ugb2JzZXJ2YXRpb25zLCB3ZSB0aGluayB0aGF0IGFsbCBjb25zdHJ1Y3RvckNhbGxiYWNrKCkg c2hvdWxkIGhhdmUgdGhlIGFib3ZlCisgICAgICAgIGlmIGNoZWNrLiBUaGlzIHBhdGNoIGFkZHMg dGhlIGlmIGNoZWNrIHRvIENvZGVHZW5lcmF0b3JWOC5wbS4gQWZ0ZXIgdGhpcyBwYXRjaCBpcyBs YW5kZWQsCisgICAgICAgIEkgd291bGQgbGlrZSB0byBhZGQgdGhlIGlmIGNoZWNrIHRvIGFsbCBl eGlzdGluZyBjdXN0b20gVjggY29uc3RydWN0b3JzLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cywg c2luY2Ugd2UgY291bGQgbm90IGZpbmQgYSB0ZXN0IGNhc2UgdGhhdCBjYXVzZXMgc29tZSB2aXNp YmxlIGJ1ZyB3aXRob3V0IHRoZSBpZiBjaGVjay4KKworICAgICAgICAqIGJpbmRpbmdzL3Njcmlw dHMvQ29kZUdlbmVyYXRvclY4LnBtOgorICAgICAgICAoR2VuZXJhdGVDb25zdHJ1Y3RvckNhbGxi YWNrKTogR2VuZXJhdGVzIGEgY29uc3RydWN0b3Igc28gdGhhdCBpdCByZXR1cm5zIGltbWVkaWF0 ZWx5IHdpdGhvdXQgZG9pbmcgYW55dGhpbmcgaWYgdGhlIGNvbnN0cnVjdG9yIGlzIGNhbGxlZCBm cm9tIHRoZSBXZWJDb3JlIGNvbnRleHQuCisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0cy90ZXN0 L1Y4L1Y4VGVzdEludGVyZmFjZS5jcHA6IFVwZGF0ZWQgdGhlIHJlc3VsdC4KKyAgICAgICAgKFdl YkNvcmU6OlY4VGVzdEludGVyZmFjZTo6Y29uc3RydWN0b3JDYWxsYmFjayk6CisgICAgICAgICog YmluZGluZ3Mvc2NyaXB0cy90ZXN0L1Y4L1Y4VGVzdE9iai5jcHA6IERpdHRvLgorICAgICAgICAo V2ViQ29yZTo6VjhUZXN0T2JqOjpjb25zdHJ1Y3RvckNhbGxiYWNrKToKKwogMjAxMS0xMC0xMiAg S2VudGFybyBIYXJhICA8aGFyYWtlbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgSW1wbGVtZW50 IGEgQmVmb3JlTG9hZEV2ZW50IGNvbnN0cnVjdG9yIGZvciBKU0MKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvQ29kZUdlbmVyYXRvclY4LnBtIGIvU291cmNlL1dl YkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9yVjgucG0KaW5kZXggYTI3NmEzNGM5 OTc0YjE3ZWFkZTc1YzFmYzRjMjgzY2Y3MTEyODM0NS4uNzgwMWFkNzZiYTIyYmNmMDlmMDFlYWUx NzFkOWNlMTRlYzA4NjdkMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2Ny aXB0cy9Db2RlR2VuZXJhdG9yVjgucG0KKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2Ny aXB0cy9Db2RlR2VuZXJhdG9yVjgucG0KQEAgLTE1MzIsNiArMTUzMiw4IEBAIHY4OjpIYW5kbGU8 djg6OlZhbHVlPiBWOCR7aW1wbENsYXNzTmFtZX06OmNvbnN0cnVjdG9yQ2FsbGJhY2soY29uc3Qg djg6OkFyZ3VtZW50CiAgICAgaWYgKCFhcmdzLklzQ29uc3RydWN0Q2FsbCgpKQogICAgICAgICBy ZXR1cm4gdGhyb3dFcnJvcigiRE9NIG9iamVjdCBjb25zdHJ1Y3RvciBjYW5ub3QgYmUgY2FsbGVk IGFzIGEgZnVuY3Rpb24uIiwgVjhQcm94eTo6VHlwZUVycm9yKTsKIAorICAgIGlmIChBbGxvd0Fs bG9jYXRpb246OmN1cnJlbnQoKSkKKyAgICAgICAgcmV0dXJuIGFyZ3MuSG9sZGVyKCk7CiBFTkQK IAogICAgIHB1c2goQGltcGxDb250ZW50LCBHZW5lcmF0ZUFyZ3VtZW50c0NvdW50Q2hlY2soJGZ1 bmN0aW9uLCAkZGF0YU5vZGUpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L3NjcmlwdHMvdGVzdC9WOC9WOFRlc3RJbnRlcmZhY2UuY3BwIGIvU291cmNlL1dlYkNvcmUvYmlu ZGluZ3Mvc2NyaXB0cy90ZXN0L1Y4L1Y4VGVzdEludGVyZmFjZS5jcHAKaW5kZXggMjU1OGI2ZGRk NDQ2YTU0Mzg4MDQ3MWY1ZjVjYzVkMjk0ZDVjZjI4ZS4uNmVhZWJhODUxODRkMTM1OTlhODgyN2M2 NWQwMGMwNjM2MGQ1YzZkMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2Ny aXB0cy90ZXN0L1Y4L1Y4VGVzdEludGVyZmFjZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmlu ZGluZ3Mvc2NyaXB0cy90ZXN0L1Y4L1Y4VGVzdEludGVyZmFjZS5jcHAKQEAgLTUwLDYgKzUwLDgg QEAgdjg6OkhhbmRsZTx2ODo6VmFsdWU+IFY4VGVzdEludGVyZmFjZTo6Y29uc3RydWN0b3JDYWxs YmFjayhjb25zdCB2ODo6QXJndW1lbnRzJgogICAgIGlmICghYXJncy5Jc0NvbnN0cnVjdENhbGwo KSkKICAgICAgICAgcmV0dXJuIHRocm93RXJyb3IoIkRPTSBvYmplY3QgY29uc3RydWN0b3IgY2Fu bm90IGJlIGNhbGxlZCBhcyBhIGZ1bmN0aW9uLiIsIFY4UHJveHk6OlR5cGVFcnJvcik7CiAKKyAg ICBpZiAoQWxsb3dBbGxvY2F0aW9uOjpjdXJyZW50KCkpCisgICAgICAgIHJldHVybiBhcmdzLkhv bGRlcigpOwogICAgIGlmIChhcmdzLkxlbmd0aCgpIDwgMSkKICAgICAgICAgcmV0dXJuIHRocm93 RXJyb3IoIk5vdCBlbm91Z2ggYXJndW1lbnRzIiwgVjhQcm94eTo6VHlwZUVycm9yKTsKIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L1Y4L1Y4VGVzdE9i ai5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvVjgvVjhUZXN0T2Jq LmNwcAppbmRleCBhM2M0ZjBjNWFkYmJkYWFhOGMyODU5OTgyNzEwMzhmZTg4NDgxMWE4Li5jYjg5 ZWRlYmVjZTE0NDY5NDFkZTdkOWJkY2VhMTU4ZDIxMDJlYjQ5IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvVjgvVjhUZXN0T2JqLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvVjgvVjhUZXN0T2JqLmNwcApAQCAtMTM5 Myw2ICsxMzkzLDggQEAgdjg6OkhhbmRsZTx2ODo6VmFsdWU+IFY4VGVzdE9iajo6Y29uc3RydWN0 b3JDYWxsYmFjayhjb25zdCB2ODo6QXJndW1lbnRzJiBhcmdzKQogICAgIGlmICghYXJncy5Jc0Nv bnN0cnVjdENhbGwoKSkKICAgICAgICAgcmV0dXJuIHRocm93RXJyb3IoIkRPTSBvYmplY3QgY29u c3RydWN0b3IgY2Fubm90IGJlIGNhbGxlZCBhcyBhIGZ1bmN0aW9uLiIsIFY4UHJveHk6OlR5cGVF cnJvcik7CiAKKyAgICBpZiAoQWxsb3dBbGxvY2F0aW9uOjpjdXJyZW50KCkpCisgICAgICAgIHJl dHVybiBhcmdzLkhvbGRlcigpOwogCiAgICAgUmVmUHRyPFRlc3RPYmo+IG9iaiA9IFRlc3RPYmo6 OmNyZWF0ZSgpOwogCg==