152408 2015-12-17 17:02:32 -0800 Avoid triggering clang's -Wundefined-bool-conversion 2016-02-17 10:12:00 -0800 1 1 1 Unclassified WebKit WebCore Misc. Other PC Linux RESOLVED FIXED P2 Trivial --- 145121 1 mcatanzaro mcatanzaro cdumez commit-queue esprehn+autocc kangil.han keith_miller mark.lam mcatanzaro msaboff ossy saam oldest_to_newest 1150145 0 mcatanzaro 2015-12-17 17:02:32 -0800 TreeScope.cpp:287 triggers clang's -Wundefined-bool-conversion warning: [2278/5753] Building CXX object Source...eFiles/WebCore.dir/dom/TreeScope.cpp.o ../../Source/WebCore/dom/TreeScope.cpp:287:8: warning: 'this' pointer cannot be null in well-defined C++ code; pointer may be assumed to always convert to true [-Wundefined-bool-conversion] (!(this) ? (WTFReportAssertionFailure("../../Source/WebCore/dom/TreeScope.cpp", 287, __PRETTY_FUNCTION__, "this"), WTFCrash()) : (void)0); ~ ^~~~ 1 warning generated. 1150146 1 mcatanzaro 2015-12-17 17:07:28 -0800 Also: [2754/5753] Building CXX object Source...MakeFiles/WebCore.dir/page/Frame.cpp.o ../../Source/WebCore/page/Frame.cpp:873:8: warning: 'this' pointer cannot be null in well-defined C++ code; pointer may be assumed to always convert to true [-Wundefined-bool-conversion] (!(this) ? (WTFReportAssertionFailure("../../Source/WebCore/page/Frame.cpp", 873, __PRETTY_FUNCTION__, "this"), WTFCrash()) : (void)0); ~ ^~~~ 1 warning generated. 1150155 2 mcatanzaro 2015-12-17 17:30:53 -0800 More complicated one: [5126/5753] Building CXX object Source...cess/Plugins/Netscape/JSNPObject.cpp.o ../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp:110:18: warning: 'this' pointer cannot be null in well-defined C++ code; pointer may be assumed to always convert to true [-Wundefined-bool-conversion] do { do { (!(this) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 110, __PRETTY_FUNCTION__, "this"), WTFCrash()) : (void)0); (!(this->structure()->structure() == this->structure()->structure()->structure()) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 110, __PRETTY_FUNCTION__, "this->structure()->structure() == this->structure()->structure()->structure()"), WTFCrash()) : (void)0); } while (0); (!(this->inherits(info())) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 110, __PRETTY_FUNCTION__, "this->inherits(info())"), WTFCrash()) : (void)0); } while (0); ~ ^~~~ ../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp:154:18: warning: 'this' pointer cannot be null in well-defined C++ code; pointer may be assumed to always convert to true [-Wundefined-bool-conversion] do { do { (!(this) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 154, __PRETTY_FUNCTION__, "this"), WTFCrash()) : (void)0); (!(this->structure()->structure() == this->structure()->structure()->structure()) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 154, __PRETTY_FUNCTION__, "this->structure()->structure() == this->structure()->structure()->structure()"), WTFCrash()) : (void)0); } while (0); (!(this->inherits(info())) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 154, __PRETTY_FUNCTION__, "this->inherits(info())"), WTFCrash()) : (void)0); } while (0); ~ ^~~~ ../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp:194:18: warning: 'this' pointer cannot be null in well-defined C++ code; pointer may be assumed to always convert to true [-Wundefined-bool-conversion] do { do { (!(this) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 194, __PRETTY_FUNCTION__, "this"), WTFCrash()) : (void)0); (!(this->structure()->structure() == this->structure()->structure()->structure()) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 194, __PRETTY_FUNCTION__, "this->structure()->structure() == this->structure()->structure()->structure()"), WTFCrash()) : (void)0); } while (0); (!(this->inherits(info())) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 194, __PRETTY_FUNCTION__, "this->inherits(info())"), WTFCrash()) : (void)0); } while (0); ~ ^~~~ ../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp:354:18: warning: 'this' pointer cannot be null in well-defined C++ code; pointer may be assumed to always convert to true [-Wundefined-bool-conversion] do { do { (!(this) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 354, __PRETTY_FUNCTION__, "this"), WTFCrash()) : (void)0); (!(this->structure()->structure() == this->structure()->structure()->structure()) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 354, __PRETTY_FUNCTION__, "this->structure()->structure() == this->structure()->structure()->structure()"), WTFCrash()) : (void)0); } while (0); (!(this->inherits(info())) ? (WTFReportAssertionFailure("../../Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp", 354, __PRETTY_FUNCTION__, "this->inherits(info())"), WTFCrash()) : (void)0); } while (0); ~ ^~~~ 4 warnings generated. 1150177 3 267603 mcatanzaro 2015-12-17 19:17:44 -0800 Created attachment 267603 Patch 1150264 4 267603 mark.lam 2015-12-18 07:23:05 -0800 Comment on attachment 267603 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=267603&action=review > Source/WebCore/dom/TreeScope.cpp:-287 > - ASSERT(this); I know style-wise, we don't like "ASSERT(!!this);", but with this change, we're losing the detection that we may be calling this method on a nullptr. Granted, it will just crash below when it derefs this to access any fields. Out of curiousity, would clang complain about "ASSERT(!!this)"? 1150321 5 mcatanzaro 2015-12-18 10:28:40 -0800 (In reply to comment #4) > I know style-wise, we don't like "ASSERT(!!this);", but with this change, > we're losing the detection that we may be calling this method on a nullptr. > Granted, it will just crash below when it derefs this to access any fields. > > Out of curiousity, would clang complain about "ASSERT(!!this)"? Yeah, Clang does also warn about ASSERT(!!this). The problem is that modern compilers (at least GCC and Clang) assume "this" is always valid, because the standard says they can, so converting "this" to a bool will always return true, and !!this is also always true. (At least in optimized builds. I am not sure whether or not that holds true at -O0; if not, then we are indeed losing a useful assert.) Anyway, I favor removing the check regardless, because I think the value of it is less than the value of not creating a mess trying to suppress the warnings. The best way I could come up with to keep the assert short of disabling -Wundefined-bool-conversion globally was this: #if COMPILER(CLANG) #if __has_warning("-Wundefined-bool-conversion") #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wundefined-bool-conversion" #endif #endif ASSERT(this); #if COMPILER(CLANG) #if __has_warning("-Wundefined-bool-conversion") #pragma clang diagnostic pop #endif #endif We definitely have to guard the #pragma because MSVCC will choke on it otherwise, I think we have to guard use of __has_warning because some compiler (older GCC?) will choke on THAT otherwise, and the __has_warning check is probably needed because GCC warns if you try to ignore a warning that doesn't exist, so I assume Clang does as well (but I did not check; if it's not needed, at least that would be a bit simpler). So that is quite a mess to have for one assert. In the future, I expect GCC will add the same warning. Then we would have this: #if COMPILER(CLANG) #if __has_warning("-Wundefined-bool-conversion") #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wundefined-bool-conversion" #endif #endif #if COMPILER(GCC) #if GCC_VERSION_AT_LEAST(n, m, o) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wundefined-bool-conversion" #endif #endif ASSERT(this); // <------ assert goes there :) #if COMPILER(GCC) #if GCC_VERSION_AT_LEAST(n, m, o) #pragma GCC diagnostic pop #endif #endif #if COMPILER(CLANG) #if __has_warning("-Wundefined-bool-conversion") #pragma clang diagnostic pop #endif #endif What really sucks about this is that Clang understands GCC pragmas, so the second set of pragmas would be unnecessary if only GCC would learn to handle __has_warning. So, I would either disable -Wundefined-bool-conversion project-wide (probably undesirable), or just remove the assert (seems less undesirable), unless you have any better ideas. 1150323 6 mcatanzaro 2015-12-18 10:31:49 -0800 (In reply to comment #5) > I think we have to guard use of __has_warning because some > compiler (older GCC?) will choke on THAT otherwise I should clarify: I believe we support some compiler (GCC?) that cannot handle preprocessor statements like: #if 0 && UNDEFINED_IF_PREVIOUS_VALUE_IS_0 #endif Hence we have to do: #if 0 #if UNDEFINED_IF_VALUE_ABOVE_IS_0 #endif #endif 1150360 7 267603 mark.lam 2015-12-18 11:32:59 -0800 Comment on attachment 267603 Patch r=me 1150436 8 267603 commit-queue 2015-12-18 16:16:41 -0800 Comment on attachment 267603 Patch Clearing flags on attachment: 267603 Committed r194303: <http://trac.webkit.org/changeset/194303> 1150437 9 commit-queue 2015-12-18 16:16:47 -0800 All reviewed patches have been landed. Closing bug. 1155080 10 267603 darin 2016-01-13 08:23:08 -0800 Comment on attachment 267603 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=267603&action=review > Source/WebCore/ChangeLog:8 > + Remove use of ASSERT(this). Saying the same thing Mark is below, I think: It’s too bad that clang is causing us to do this. There’s no runtime check to detect accidentally calling a member function with a null pointer, so there might have been value in ASSERT(this), we just needed a way to write it that let clang know why we were doing it. On the other hand, null dereferences just one line later probably mean these aren’t all that valuable so I think I’m going to just let go and not discuss it further. 1165613 11 mcatanzaro 2016-02-17 10:12:00 -0800 I asked a GCC developer about this: "ASSERT(this) is pointless, it is testing if undefined behavior didn't happen after the fact, that is just too late. As I said, use -fsanitize=undefined to make sure you don't call methods on nullptr." https://lists.fedoraproject.org/archives/list/devel@lists.fedoraproject.org/message/WX26YZOE5WRYPOEE7HJOZ56QPO7XQ5RS/ 267603 2015-12-17 19:17:44 -0800 2015-12-18 16:16:41 -0800 Patch bug-152408-20151217211705.patch text/plain 6686 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMTk0MjQ4CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAz MDJhMTI1YzU3MjVhZmFiZWU2NDVkYTM1M2JiNmQzYWE0Y2YyZGQ0Li41NzBmMDUwMWNmMDg1N2Rk OThkMGEwNWFkOWExZTA3MzEwNjdmMDM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNSBAQAorMjAxNS0xMi0xNyAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGln YWxpYS5jb20+CisKKyAgICAgICAgQXZvaWQgdHJpZ2dlcmluZyBjbGFuZydzIC1XdW5kZWZpbmVk LWJvb2wtY29udmVyc2lvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTUyNDA4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgQWRkIEFTU0VSVF9USElTX0dDX09CSkVDVF9MT09LU19WQUxJRCBhbmQgQVNTRVJU X1RISVNfR0NfT0JKRUNUX0lOSEVSSVRTIHRvIGF2b2lkIHVzZSBvZgorICAgICAgICBBU1NFUlQo dGhpcykgYnkgQVNTRVJUX0dDX09CSkVDVF9MT09LU19WQUxJRCBhbmQgQVNTRVJUX0dDX09CSkVD VF9JTkhFUklUUy4KKworICAgICAgICAqIGhlYXAvR0NBc3NlcnRpb25zLmg6CisKIDIwMTUtMTIt MTcgIEtlaXRoIE1pbGxlciAgPGtlaXRoX21pbGxlckBhcHBsZS5jb20+CiAKICAgICAgICAgW0VT Nl0gQWRkIHN1cHBvcnQgZm9yIFN5bWJvbC5oYXNJbnN0YW5jZQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDViYjg5 MDcwMTc3MzNmNTJjNDBiMjAzZjVlMzQxYjQ3NmU4N2ExNGEuLjU5OWZlYTQyODUxZDY4M2Q0YjJh ZWU4MTZkN2ZiYTc4MjFmNWQwYjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNyBAQAorMjAxNS0x Mi0xNyAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGlnYWxpYS5jb20+CisKKyAgICAg ICAgQXZvaWQgdHJpZ2dlcmluZyBjbGFuZydzIC1XdW5kZWZpbmVkLWJvb2wtY29udmVyc2lvbgor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUyNDA4CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVtb3ZlIHVz ZSBvZiBBU1NFUlQodGhpcykuCisKKyAgICAgICAgKiBkb20vVHJlZVNjb3BlLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OlRyZWVTY29wZTo6YWRvcHRJZk5lZWRlZCk6CisgICAgICAgICogcGFnZS9G cmFtZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZTo6Y3JlYXRlVmlldyk6CisKIDIwMTUt MTItMTYgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNlckBhcHBsZS5jb20+CiAKICAgICAgICAg Vmlld3BvcnRDb25maWd1cmF0aW9uIGZ1bmN0aW9ucyBzaG91bGQgcmV0dXJuIGEgYm9vbCB0byBz YXkgaWYgYW55dGhpbmcgY2hhbmdlZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdl TG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDIyOTJiZjU1NjY1ZjQzY2ExYTY1 YzI5ZmFhMTQ5MmZiYzkwYTllYTIuLmYzYzkwZDJiZjNjMmQyYzI5NDJiOTlhNmY0ZjM5NDJmNTEw ODBjMDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2Uv V2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOCBAQAorMjAxNS0xMi0xNyAgTWljaGFlbCBD YXRhbnphcm8gIDxtY2F0YW56YXJvQGlnYWxpYS5jb20+CisKKyAgICAgICAgQXZvaWQgdHJpZ2dl cmluZyBjbGFuZydzIC1XdW5kZWZpbmVkLWJvb2wtY29udmVyc2lvbgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUyNDA4CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVXNlIEFTU0VSVF9USElTX0dDX09CSkVD VF9JTkhFUklUUyB3aGVyZSBuZWVkZWQuCisKKyAgICAgICAgKiBXZWJQcm9jZXNzL1BsdWdpbnMv TmV0c2NhcGUvSlNOUE9iamVjdC5jcHA6CisgICAgICAgIChXZWJLaXQ6OkpTTlBPYmplY3Q6OmNh bGxNZXRob2QpOgorICAgICAgICAoV2ViS2l0OjpKU05QT2JqZWN0OjpjYWxsT2JqZWN0KToKKyAg ICAgICAgKFdlYktpdDo6SlNOUE9iamVjdDo6Y2FsbENvbnN0cnVjdG9yKToKKyAgICAgICAgKFdl YktpdDo6SlNOUE9iamVjdDo6ZGVsZXRlUHJvcGVydHkpOgorCiAyMDE1LTEyLTE3ICBTaW1vbiBG cmFzZXIgIDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgogCiAgICAgICAgIERpc2FibGUgdmlld3Bv cnQgInNocmluayB0byBmaXQiIG91dHNpZGUgb2YgbXVsdGl0YXNraW5nIG1vZGUKZGlmZiAtLWdp dCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0dDQXNzZXJ0aW9ucy5oIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL2hlYXAvR0NBc3NlcnRpb25zLmgKaW5kZXggZmNiMTM1YWM1MzI1ODhlNzIx Mjk1NWEwNzk2MmEzNWE2ZGE2YzkyZC4uODM2MjQ0ZmU2OWYxMGQ5ZmI2MTNiOGE4NTczNjg0YzBj MjM4NjhkZCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvR0NBc3NlcnRp b25zLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvR0NBc3NlcnRpb25zLmgKQEAg LTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDEyIEFwcGxlIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxNSBJZ2FsaWEgUy5MLgogICoKICAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC00MCw5ICs0MSwyMSBAQAogICAgIFJFTEVBU0Vf QVNTRVJUKG9iamVjdC0+aW5oZXJpdHMoY2xhc3NJbmZvKSk7IFwKIH0gd2hpbGUgKDApCiAKKy8v IFVzZWQgdG8gYXZvaWQgdHJpZ2dlcmluZyAtV3VuZGVmaW5lZC1ib29sLWNvbnZlcnNpb24uCisj ZGVmaW5lIEFTU0VSVF9USElTX0dDX09CSkVDVF9MT09LU19WQUxJRCgpIGRvIHsgXAorICAgIFJF TEVBU0VfQVNTRVJUKHRoaXMtPnN0cnVjdHVyZSgpLT5zdHJ1Y3R1cmUoKSA9PSB0aGlzLT5zdHJ1 Y3R1cmUoKS0+c3RydWN0dXJlKCktPnN0cnVjdHVyZSgpKTsgXAorfSB3aGlsZSAoMCkKKworI2Rl ZmluZSBBU1NFUlRfVEhJU19HQ19PQkpFQ1RfSU5IRVJJVFMoY2xhc3NJbmZvKSBkbyB7XAorICAg IEFTU0VSVF9USElTX0dDX09CSkVDVF9MT09LU19WQUxJRCgpOyBcCisgICAgUkVMRUFTRV9BU1NF UlQodGhpcy0+aW5oZXJpdHMoY2xhc3NJbmZvKSk7IFwKK30gd2hpbGUgKDApCisKICNlbHNlCiAj ZGVmaW5lIEFTU0VSVF9HQ19PQkpFQ1RfTE9PS1NfVkFMSUQoY2VsbCkgZG8geyAodm9pZCljZWxs OyB9IHdoaWxlICgwKQogI2RlZmluZSBBU1NFUlRfR0NfT0JKRUNUX0lOSEVSSVRTKG9iamVjdCwg Y2xhc3NJbmZvKSBkbyB7ICh2b2lkKW9iamVjdDsgKHZvaWQpY2xhc3NJbmZvOyB9IHdoaWxlICgw KQorI2RlZmluZSBBU1NFUlRfVEhJU19HQ19PQkpFQ1RfTE9PS1NfVkFMSUQoKQorI2RlZmluZSBB U1NFUlRfVEhJU19HQ19PQkpFQ1RfSU5IRVJJVFMoY2xhc3NJbmZvKSBkbyB7ICh2b2lkKWNsYXNz SW5mbzsgfSB3aGlsZSAoMCkKICNlbmRpZgogCiAjZGVmaW5lIFNUQVRJQ19BU1NFUlRfSVNfVFJJ VklBTExZX0RFU1RSVUNUSUJMRShrbGFzcykgc3RhdGljX2Fzc2VydChzdGQ6OmlzX3RyaXZpYWxs eV9kZXN0cnVjdGlibGU8a2xhc3M+Ojp2YWx1ZSwgI2tsYXNzICIgbXVzdCBoYXZlIGEgdHJpdmlh bCBkZXN0cnVjdG9yIikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9UcmVlU2NvcGUu Y3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1RyZWVTY29wZS5jcHAKaW5kZXggOGExZWZhYTFlZmI3 MmQ0YjM5Yjk5YTI3ZTRhNTViZWIyNTE4NzEzMC4uMTIzODhmMTRjM2Y1YTE2NWU0Y2ViZjZjY2Fm ZmRiNWQ1MzgzNjQzNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL1RyZWVTY29wZS5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL1RyZWVTY29wZS5jcHAKQEAgLTI4NCw3ICsyODQs NiBAQCBFbGVtZW50KiBUcmVlU2NvcGU6OmZpbmRBbmNob3IoY29uc3QgU3RyaW5nJiBuYW1lKQog CiB2b2lkIFRyZWVTY29wZTo6YWRvcHRJZk5lZWRlZChOb2RlKiBub2RlKQogewotICAgIEFTU0VS VCh0aGlzKTsKICAgICBBU1NFUlQobm9kZSk7CiAgICAgQVNTRVJUKCFub2RlLT5pc0RvY3VtZW50 Tm9kZSgpKTsKICAgICBBU1NFUlQoIW5vZGUtPm1fZGVsZXRpb25IYXNCZWd1bik7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv RnJhbWUuY3BwCmluZGV4IGVhNWQ5MmU0MDA5NDYyZmE4ZTZiZjU5Y2ZiMzNmNjVkMGI0MWY4MDMu LmM0Yzg2NzNlNjQ4ODRlZGJjY2ZiNTc0MzhlYWY5ZmI4NjA5NWJmYWQgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJh bWUuY3BwCkBAIC04NzAsNyArODcwLDYgQEAgdm9pZCBGcmFtZTo6Y3JlYXRlVmlldyhjb25zdCBJ bnRTaXplJiB2aWV3cG9ydFNpemUsIGNvbnN0IENvbG9yJiBiYWNrZ3JvdW5kQ29sb3IKICAgICBi b29sIHVzZUZpeGVkTGF5b3V0LCBTY3JvbGxiYXJNb2RlIGhvcml6b250YWxTY3JvbGxiYXJNb2Rl LCBib29sIGhvcml6b250YWxMb2NrLAogICAgIFNjcm9sbGJhck1vZGUgdmVydGljYWxTY3JvbGxi YXJNb2RlLCBib29sIHZlcnRpY2FsTG9jaykKIHsKLSAgICBBU1NFUlQodGhpcyk7CiAgICAgQVNT RVJUKG1fcGFnZSk7CiAKICAgICBib29sIGlzTWFpbkZyYW1lID0gdGhpcy0+aXNNYWluRnJhbWUo KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2Fw ZS9KU05QT2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRz Y2FwZS9KU05QT2JqZWN0LmNwcAppbmRleCBjZjVjNzFkZGE5MmFiMmQ4NjNkMTcwZjlhMDNhZGZh MGViOTk4ZDZkLi5jOWE5YzU1ZTQyZTMxNTUwMzZhMTkxODQxOTY5NjU1NThjMTE0ODkwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvSlNOUE9i amVjdC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBl L0pTTlBPYmplY3QuY3BwCkBAIC0xMDcsNyArMTA3LDcgQEAgTlBPYmplY3QqIEpTTlBPYmplY3Q6 OmxlYWtOUE9iamVjdCgpCiAKIEpTVmFsdWUgSlNOUE9iamVjdDo6Y2FsbE1ldGhvZChFeGVjU3Rh dGUqIGV4ZWMsIE5QSWRlbnRpZmllciBtZXRob2ROYW1lKQogewotICAgIEFTU0VSVF9HQ19PQkpF Q1RfSU5IRVJJVFModGhpcywgaW5mbygpKTsKKyAgICBBU1NFUlRfVEhJU19HQ19PQkpFQ1RfSU5I RVJJVFMoaW5mbygpKTsKICAgICBpZiAoIW1fbnBPYmplY3QpCiAgICAgICAgIHJldHVybiB0aHJv d0ludmFsaWRBY2Nlc3NFcnJvcihleGVjKTsKIApAQCAtMTUxLDcgKzE1MSw3IEBAIEpTVmFsdWUg SlNOUE9iamVjdDo6Y2FsbE1ldGhvZChFeGVjU3RhdGUqIGV4ZWMsIE5QSWRlbnRpZmllciBtZXRo b2ROYW1lKQogCiBKU0M6OkpTVmFsdWUgSlNOUE9iamVjdDo6Y2FsbE9iamVjdChKU0M6OkV4ZWNT dGF0ZSogZXhlYykKIHsKLSAgICBBU1NFUlRfR0NfT0JKRUNUX0lOSEVSSVRTKHRoaXMsIGluZm8o KSk7CisgICAgQVNTRVJUX1RISVNfR0NfT0JKRUNUX0lOSEVSSVRTKGluZm8oKSk7CiAgICAgaWYg KCFtX25wT2JqZWN0KQogICAgICAgICByZXR1cm4gdGhyb3dJbnZhbGlkQWNjZXNzRXJyb3IoZXhl Yyk7CiAKQEAgLTE5MSw3ICsxOTEsNyBAQCBKU0M6OkpTVmFsdWUgSlNOUE9iamVjdDo6Y2FsbE9i amVjdChKU0M6OkV4ZWNTdGF0ZSogZXhlYykKIAogSlNWYWx1ZSBKU05QT2JqZWN0OjpjYWxsQ29u c3RydWN0b3IoRXhlY1N0YXRlKiBleGVjKQogewotICAgIEFTU0VSVF9HQ19PQkpFQ1RfSU5IRVJJ VFModGhpcywgaW5mbygpKTsKKyAgICBBU1NFUlRfVEhJU19HQ19PQkpFQ1RfSU5IRVJJVFMoaW5m bygpKTsKICAgICBpZiAoIW1fbnBPYmplY3QpCiAgICAgICAgIHJldHVybiB0aHJvd0ludmFsaWRB Y2Nlc3NFcnJvcihleGVjKTsKIApAQCAtMzUxLDcgKzM1MSw3IEBAIGJvb2wgSlNOUE9iamVjdDo6 ZGVsZXRlUHJvcGVydHlCeUluZGV4KEpTQ2VsbCogY2VsbCwgRXhlY1N0YXRlKiBleGVjLCB1bnNp Z25lZCBwCiAKIGJvb2wgSlNOUE9iamVjdDo6ZGVsZXRlUHJvcGVydHkoRXhlY1N0YXRlKiBleGVj LCBOUElkZW50aWZpZXIgcHJvcGVydHlOYW1lKQogewotICAgIEFTU0VSVF9HQ19PQkpFQ1RfSU5I RVJJVFModGhpcywgaW5mbygpKTsKKyAgICBBU1NFUlRfVEhJU19HQ19PQkpFQ1RfSU5IRVJJVFMo aW5mbygpKTsKIAogICAgIC8vIElmIHRoZSBwcm9wZXJ0eU5hbWUgaXMgc3ltYm9sLgogICAgIGlm ICghcHJvcGVydHlOYW1lKQo=