210067 2020-04-06 13:19:52 -0700 [Clang 10] Fix -Wimplicit-int-float-conversion compilation warnings in TestWebKitAPI 2020-04-07 22:47:14 -0700 1 1 1 Unclassified WebKit Tools / Tests WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=204834 InRadar P2 Normal --- 1 fujii fujii darin jchaffraix webkit-bug-importer zalan oldest_to_newest 1638273 0 fujii 2020-04-06 13:19:52 -0700 [Clang 10] Fix -Wimplicit-int-float-conversion compilation warnings in TestWebKitAPI This is a sub-task of Bug 204834. Clang 10 reports compilation warnings in TestWebKitAPI: > [2108/5311] Building CXX object Tools\TestWebKitAPI\CMakeFiles\TestWTFLib.dir\Tests\WTF\MathExtras.cpp.obj > ..\..\Tools\TestWebKitAPI\Tests\WTF\MathExtras.cpp(96,20): warning: implicit conversion from 'int' to 'float' changes value from 2147483647 to 2147483648 [-Wimplicit-int-float-conversion] > float maxInt = std::numeric_limits<int>::max(); > ~~~~~~ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > 1 warning generated. > [3798/5311] Building CXX object Tools\TestWebKitAPI\CMakeFiles\TestWebCoreLib.dir\Tests\WebCore\FloatRect.cpp.obj > ..\..\Tools\TestWebKitAPI\Tests\WebCore\FloatRect.cpp(773,32): warning: implicit conversion from 'int' to 'float' changes value from 2147483647 to 2147483648 [-Wimplicit-int-float-conversion] > maxIntRect.shiftMaxXEdgeTo(INT_MAX); > ~~~~~~~~~~~~~~~ ^~~~~~~ > C:\PROGRA~1\LLVM\lib\clang\10.0.0\include\limits.h(46,19): note: expanded from macro 'INT_MAX' > #define INT_MAX __INT_MAX__ > ^~~~~~~~~~~ > <built-in>(81,21): note: expanded from here > #define __INT_MAX__ 2147483647 > ^~~~~~~~~~ > ..\..\Tools\TestWebKitAPI\Tests\WebCore\FloatRect.cpp(774,32): warning: implicit conversion from 'int' to 'float' changes value from 2147483647 to 2147483648 [-Wimplicit-int-float-conversion] > maxIntRect.shiftMaxYEdgeTo(INT_MAX); > ~~~~~~~~~~~~~~~ ^~~~~~~ > C:\PROGRA~1\LLVM\lib\clang\10.0.0\include\limits.h(46,19): note: expanded from macro 'INT_MAX' > #define INT_MAX __INT_MAX__ > ^~~~~~~~~~~ > <built-in>(81,21): note: expanded from here > #define __INT_MAX__ 2147483647 > ^~~~~~~~~~ > 2 warnings generated. See also: r259537 (for WTF) and r259588 (for JavaScriptCore) 1638277 1 395611 fujii 2020-04-06 13:24:54 -0700 Created attachment 395611 Patch 1638292 2 395611 darin 2020-04-06 13:45:48 -0700 Comment on attachment 395611 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395611&action=review > Tools/TestWebKitAPI/Tests/WTF/MathExtras.cpp:96 > + float maxInt = maxPlusOne<int>; Local variable name is not good now, since it's past the max int. Not clear if this is OK for what we are testing. We want to test values right around the border of what fits in an int to see they are handled correctly. It’s not OK to just test std::numeric_limits<int>::max() + 1, we also want to test smaller values. > Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:774 > - maxIntRect.shiftMaxXEdgeTo(INT_MAX); > - maxIntRect.shiftMaxYEdgeTo(INT_MAX); > + maxIntRect.shiftMaxXEdgeTo(maxPlusOne<int>); > + maxIntRect.shiftMaxYEdgeTo(maxPlusOne<int>); This is not what we are trying to test. We are trying to test INT_MAX, not INT_MAX + 1. > Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:781 > - EXPECT_EQ(INT_MAX, enclosed2.width()); > - EXPECT_EQ(INT_MAX, enclosed2.height()); > + EXPECT_EQ(maxPlusOne<int>, enclosed2.width()); > + EXPECT_EQ(maxPlusOne<int>, enclosed2.height()); This looks wrong. Why would a floating point number be involved in checking the resulting integer value? 1638307 3 395611 fujii 2020-04-06 14:16:39 -0700 Comment on attachment 395611 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395611&action=review >> Tools/TestWebKitAPI/Tests/WTF/MathExtras.cpp:96 >> + float maxInt = maxPlusOne<int>; > > Local variable name is not good now, since it's past the max int. Not clear if this is OK for what we are testing. We want to test values right around the border of what fits in an int to see they are handled correctly. It’s not OK to just test std::numeric_limits<int>::max() + 1, we also want to test smaller values. Agreed. I will test INT_MAX - 1 and INT_MAX + 1. >> Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:774 >> + maxIntRect.shiftMaxYEdgeTo(maxPlusOne<int>); > > This is not what we are trying to test. We are trying to test INT_MAX, not INT_MAX + 1. float can't keep the precision of INT_MAX. As the compilation warning explains, INT_MAX is converted a float of INT_MAX+1 in ordinary architectures. The implementation of FloatRect doesn't use 'int' at all. I don't think it makes sense to test both INT_MAX-1 and INT_MAX+1 here. What do you think? >> Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:781 >> + EXPECT_EQ(maxPlusOne<int>, enclosed2.height()); > > This looks wrong. Why would a floating point number be involved in checking the resulting integer value? They (maxPlusOne<int>, enclosed2.width() and enclosed2.height()) are all float type. What do you mean? 1638308 4 395611 darin 2020-04-06 14:18:57 -0700 Comment on attachment 395611 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395611&action=review >>> Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:774 >>> + maxIntRect.shiftMaxYEdgeTo(maxPlusOne<int>); >> >> This is not what we are trying to test. We are trying to test INT_MAX, not INT_MAX + 1. > > float can't keep the precision of INT_MAX. As the compilation warning explains, INT_MAX is converted a float of INT_MAX+1 in ordinary architectures. > The implementation of FloatRect doesn't use 'int' at all. I don't think it makes sense to test both INT_MAX-1 and INT_MAX+1 here. > What do you think? We should test float values closest to INT_MAX, just below, ==, just above. Not sure how to generate those values. >>> Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:781 >>> + EXPECT_EQ(maxPlusOne<int>, enclosed2.height()); >> >> This looks wrong. Why would a floating point number be involved in checking the resulting integer value? > > They (maxPlusOne<int>, enclosed2.width() and enclosed2.height()) are all float type. What do you mean? No, they are not. enclosed2 is an IntRect. WebCore::enclosingIntRect returns an IntRect. 1638316 5 395611 fujii 2020-04-06 14:27:57 -0700 Comment on attachment 395611 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395611&action=review >>>> Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:781 >>>> + EXPECT_EQ(maxPlusOne<int>, enclosed2.height()); >>> >>> This looks wrong. Why would a floating point number be involved in checking the resulting integer value? >> >> They (maxPlusOne<int>, enclosed2.width() and enclosed2.height()) are all float type. What do you mean? > > No, they are not. enclosed2 is an IntRect. WebCore::enclosingIntRect returns an IntRect. Oh my bad. You are right. 1638317 6 395611 fujii 2020-04-06 14:30:52 -0700 Comment on attachment 395611 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395611&action=review >>>> Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:774 >>>> + maxIntRect.shiftMaxYEdgeTo(maxPlusOne<int>); >>> >>> This is not what we are trying to test. We are trying to test INT_MAX, not INT_MAX + 1. >> >> float can't keep the precision of INT_MAX. As the compilation warning explains, INT_MAX is converted a float of INT_MAX+1 in ordinary architectures. >> The implementation of FloatRect doesn't use 'int' at all. I don't think it makes sense to test both INT_MAX-1 and INT_MAX+1 here. >> What do you think? > > We should test float values closest to INT_MAX, just below, ==, just above. Not sure how to generate those values. Yeah, agreed. I was wrong. They are reasonable tests for enclosingIntRect. 1638420 7 395611 fujii 2020-04-06 19:17:38 -0700 Comment on attachment 395611 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395611&action=review >>>>> Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:774 >>>>> + maxIntRect.shiftMaxYEdgeTo(maxPlusOne<int>); >>>> >>>> This is not what we are trying to test. We are trying to test INT_MAX, not INT_MAX + 1. >>> >>> float can't keep the precision of INT_MAX. As the compilation warning explains, INT_MAX is converted a float of INT_MAX+1 in ordinary architectures. >>> The implementation of FloatRect doesn't use 'int' at all. I don't think it makes sense to test both INT_MAX-1 and INT_MAX+1 here. >>> What do you think? >> >> We should test float values closest to INT_MAX, just below, ==, just above. Not sure how to generate those values. > > Yeah, agreed. I was wrong. They are reasonable tests for enclosingIntRect. Umm, this is not simple as I thought. This is a test case of combining shiftMaxXEdgeTo and enclosingIntRect. It's enough to test int overflow by doing shiftMaxXEdgeTo(0) because x is INT_MIN. I can't find out a good way to test non-overflow edge case for them. 1638425 8 395645 fujii 2020-04-06 19:43:21 -0700 Created attachment 395645 Patch 1638698 9 395645 darin 2020-04-07 11:53:08 -0700 Comment on attachment 395645 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395645&action=review > Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:774 > - maxIntRect.shiftMaxXEdgeTo(INT_MAX); > - maxIntRect.shiftMaxYEdgeTo(INT_MAX); > + maxIntRect.shiftMaxXEdgeTo(0); > + maxIntRect.shiftMaxYEdgeTo(0); Seems like we should use some positive number larger than 0 but smaller than INT_MAX instead. 1638776 10 395645 fujii 2020-04-07 13:42:09 -0700 Comment on attachment 395645 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395645&action=review >> Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:774 >> + maxIntRect.shiftMaxYEdgeTo(0); > > Seems like we should use some positive number larger than 0 but smaller than INT_MAX instead. Why? For signed integer representation other than two’s complement? I will replace 0 with "INT_MAX / 2". Sounds good? 1638778 11 395645 fujii 2020-04-07 13:47:35 -0700 Comment on attachment 395645 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395645&action=review >>> Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:774 >>> + maxIntRect.shiftMaxYEdgeTo(0); >> >> Seems like we should use some positive number larger than 0 but smaller than INT_MAX instead. > > Why? For signed integer representation other than two’s complement? > I will replace 0 with "INT_MAX / 2". Sounds good? Oops. It's not good. > ..\..\Tools\TestWebKitAPI\Tests\WebCore\FloatRect.cpp(773,40): warning: implicit conversion from 'int' to 'float' changes value from 1073741823 to 1073741824 [-Wimplicit-int-float-conversion] > maxIntRect.shiftMaxXEdgeTo(INT_MAX / 2); > ~~~~~~~~~~~~~~~ ~~~~~~~~^~~ 1638784 12 395734 fujii 2020-04-07 13:54:42 -0700 Created attachment 395734 Patch for landing 1638883 13 395645 darin 2020-04-07 16:47:21 -0700 Comment on attachment 395645 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395645&action=review >>>> Tools/TestWebKitAPI/Tests/WebCore/FloatRect.cpp:774 >>>> + maxIntRect.shiftMaxYEdgeTo(0); >>> >>> Seems like we should use some positive number larger than 0 but smaller than INT_MAX instead. >> >> Why? For signed integer representation other than two’s complement? >> I will replace 0 with "INT_MAX / 2". Sounds good? > > Oops. It's not good. I was just confused. I thought that MAX was the one with larger magnitude, not MIN. So 0 was good enough. But I think 30 is even better. 1638942 14 ews-feeder 2020-04-07 22:46:30 -0700 Committed r259704: <https://trac.webkit.org/changeset/259704> All reviewed patches have been landed. Closing bug and clearing flags on attachment 395734. 1638943 15 webkit-bug-importer 2020-04-07 22:47:14 -0700 <rdar://problem/61432578> 395611 2020-04-06 13:24:54 -0700 2020-04-06 19:43:14 -0700 Patch bug-210067-20200407052453.patch text/plain 3624 fujii U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5NTM3CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNWNjODJmNDllMzgwMzY4MDQwNjEwMDlhOTZmYjhmMDFl NzFkNmVlMC4uMGRlMzE0ZjQ0ZjFmMGJhMTliODg5Y2U0YmQ4ZDhhOGNiZGVhYWI2NSAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIw IEBACisyMDIwLTA0LTA2ICBGdWppaSBIaXJvbm9yaSAgPEhpcm9ub3JpLkZ1amlpQHNvbnkuY29t PgorCisgICAgICAgIFtDbGFuZyAxMF0gRml4IC1XaW1wbGljaXQtaW50LWZsb2F0LWNvbnZlcnNp b24gY29tcGlsYXRpb24gd2FybmluZ3MgaW4gVGVzdFdlYktpdEFQSQorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEwMDY3CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ2xhbmcgMTAgcmVwb3J0cyBhIGNvbXBp bGF0aW9uIHdhcm5pbmcgZm9yIGludCB0byBmbG9hdAorICAgICAgICBjb252ZXJzaW9ucyBsb3Np bmcgdGhlIHByZWNpc2lvbi4KKworICAgICAgICBVc2UgbWF4UGx1c09uZTxpbnQ+IGluc3RlYWQg b2Ygc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+OjptYXgoKS4KKworICAgICAgICAqIFRlc3RXZWJL aXRBUEkvVGVzdHMvV1RGL01hdGhFeHRyYXMuY3BwOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6 VEVTVChXVEYuY2xhbXBUb0ludGVnZXJGbG9hdCkpOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkv VGVzdHMvV2ViQ29yZS9GbG9hdFJlY3QuY3BwOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVT VChGbG9hdFJlY3QuRW5jbG9zaW5nSW50UmVjdCkpOgorCiAyMDIwLTA0LTA0ICBXZW5zb24gSHNp ZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBldmVuIG1vcmUgbG9n Z2luZyB0byB0cnkgYW5kIGRpYWdub3NlIDx3ZWJraXQub3JnL2IvMjA5Njg1PgpkaWZmIC0tZ2l0 IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvTWF0aEV4dHJhcy5jcHAgYi9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9NYXRoRXh0cmFzLmNwcAppbmRleCA2NzZkMzc1ZTk0NmU1 ZGNhMzcyZTlmNGUwMWI5OGRjZTdlZjUyMzFlLi5lOTRlMGY4NTdlYTNmMDQ1MDhjNGQxNDE2OTBi NTIyMDYwYWNjNTE5IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9N YXRoRXh0cmFzLmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9NYXRoRXh0 cmFzLmNwcApAQCAtOTMsNyArOTMsNyBAQCBURVNUKFdURiwgY2xhbXBUb0ludGVnZXJGbG9hdCkK ICAgICAvLyBUaGlzIHRlc3QgaXMgaW5hY2N1cmF0ZSBhcyBmbG9hdHMgd2lsbCByb3VuZCB0aGUg bWluIC8gbWF4IGludGVnZXIKICAgICAvLyBkdWUgdG8gdGhlIG5hcnJvdyBtYW50aXNzYS4gSG93 ZXZlciBpdCB3aWxsIHByb3Blcmx5IGNoZWNrcyB3aXRoaW4KICAgICAvLyAoY2xvc2UgdG8gdGhl IGV4dHJlbWUpIGFuZCBvdXRzaWRlIHRoZSBpbnRlZ2VyIHJhbmdlLgotICAgIGZsb2F0IG1heElu dCA9IHN0ZDo6bnVtZXJpY19saW1pdHM8aW50Pjo6bWF4KCk7CisgICAgZmxvYXQgbWF4SW50ID0g bWF4UGx1c09uZTxpbnQ+OwogICAgIGZsb2F0IG1pbkludCA9IHN0ZDo6bnVtZXJpY19saW1pdHM8 aW50Pjo6bWluKCk7CiAgICAgZmxvYXQgb3ZlcmZsb3dJbnQgPSBtYXhJbnQgKiAxLjE7CiAgICAg ZmxvYXQgdW5kZXJmbG93SW50ID0gbWluSW50ICogMS4xOwpAQCAtMTAxLDEyICsxMDEsMTEgQEAg VEVTVChXVEYsIGNsYW1wVG9JbnRlZ2VyRmxvYXQpCiAgICAgRVhQRUNUX0dUKG92ZXJmbG93SW50 LCBtYXhJbnQpOwogICAgIEVYUEVDVF9MVCh1bmRlcmZsb3dJbnQsIG1pbkludCk7CiAKLSAgICAv LyBJZiBtYXhJbnQgPT0gMl4zMSAtIDEgKGllIG9uIEkzMiBhcmNoaXRlY3R1cmUpLCB0aGUgY2xv c2VzdCBmbG9hdCB1c2VkIHRvIHJlcHJlc2VudCBpdCBpcyAyXjMxLgotICAgIEVYUEVDVF9ORUFS KGNsYW1wVG9JbnRlZ2VyKG1heEludCksIG1heEludCwgMSk7Ci0gICAgRVhQRUNUX0VRKGNsYW1w VG9JbnRlZ2VyKG1pbkludCksIG1pbkludCk7CisgICAgRVhQRUNUX0VRKGNsYW1wVG9JbnRlZ2Vy KG1heEludCksIHN0ZDo6bnVtZXJpY19saW1pdHM8aW50Pjo6bWF4KCkpOworICAgIEVYUEVDVF9F UShjbGFtcFRvSW50ZWdlcihtaW5JbnQpLCBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1pbigp KTsKIAotICAgIEVYUEVDVF9ORUFSKGNsYW1wVG9JbnRlZ2VyKG92ZXJmbG93SW50KSwgbWF4SW50 LCAxKTsKLSAgICBFWFBFQ1RfRVEoY2xhbXBUb0ludGVnZXIodW5kZXJmbG93SW50KSwgbWluSW50 KTsKKyAgICBFWFBFQ1RfRVEoY2xhbXBUb0ludGVnZXIob3ZlcmZsb3dJbnQpLCBzdGQ6Om51bWVy aWNfbGltaXRzPGludD46Om1heCgpKTsKKyAgICBFWFBFQ1RfRVEoY2xhbXBUb0ludGVnZXIodW5k ZXJmbG93SW50KSwgc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+OjptaW4oKSk7CiB9CiAKIFRFU1Qo V1RGLCBjbGFtcFRvSW50ZWdlckRvdWJsZSkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViQ29yZS9GbG9hdFJlY3QuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJDb3JlL0Zsb2F0UmVjdC5jcHAKaW5kZXggZWY2ZGIwMWVmZTY2NjFiYjZiZDhmYjdiMmE0 MTQzYzFkZTNjNjgxYy4uOWUxNTk3Y2E5ZTY4NjhhOWQ3MGNhZmQ4OGI0NzdiYWUwOTk1Y2M4ZCAx MDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0Zsb2F0UmVjdC5j cHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0Zsb2F0UmVjdC5jcHAK QEAgLTc3MCwxNSArNzcwLDE1IEBAIFRFU1QoRmxvYXRSZWN0LCBFbmNsb3NpbmdJbnRSZWN0KQog ICAgIEVYUEVDVF9FUSg3ODksIGVuY2xvc2VkLm1heFkoKSk7CiAKICAgICBXZWJDb3JlOjpGbG9h dFJlY3QgbWF4SW50UmVjdChJTlRfTUlOLCBJTlRfTUlOLCAwLCAwKTsKLSAgICBtYXhJbnRSZWN0 LnNoaWZ0TWF4WEVkZ2VUbyhJTlRfTUFYKTsKLSAgICBtYXhJbnRSZWN0LnNoaWZ0TWF4WUVkZ2VU byhJTlRfTUFYKTsKKyAgICBtYXhJbnRSZWN0LnNoaWZ0TWF4WEVkZ2VUbyhtYXhQbHVzT25lPGlu dD4pOworICAgIG1heEludFJlY3Quc2hpZnRNYXhZRWRnZVRvKG1heFBsdXNPbmU8aW50Pik7CiAK ICAgICBhdXRvIGVuY2xvc2VkMiA9IFdlYkNvcmU6OmVuY2xvc2luZ0ludFJlY3QobWF4SW50UmVj dCk7CiAKICAgICBFWFBFQ1RfRVEoSU5UX01JTiwgZW5jbG9zZWQyLngoKSk7CiAgICAgRVhQRUNU X0VRKElOVF9NSU4sIGVuY2xvc2VkMi55KCkpOwotICAgIEVYUEVDVF9FUShJTlRfTUFYLCBlbmNs b3NlZDIud2lkdGgoKSk7Ci0gICAgRVhQRUNUX0VRKElOVF9NQVgsIGVuY2xvc2VkMi5oZWlnaHQo KSk7CisgICAgRVhQRUNUX0VRKG1heFBsdXNPbmU8aW50PiwgZW5jbG9zZWQyLndpZHRoKCkpOwor ICAgIEVYUEVDVF9FUShtYXhQbHVzT25lPGludD4sIGVuY2xvc2VkMi5oZWlnaHQoKSk7CiB9CiAK IFRFU1QoRmxvYXRSZWN0LCBSb3VuZGVkSW50UmVjdCkK 395645 2020-04-06 19:43:21 -0700 2020-04-07 13:54:25 -0700 Patch bug-210067-20200407114320.patch text/plain 3853 fujii U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5NTM3CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNWNjODJmNDllMzgwMzY4MDQwNjEwMDlhOTZmYjhmMDFl NzFkNmVlMC4uYzU0ZTUwNTdjYjdlNmUyMTQyMmY2ZGRlNTc5MmRmM2E0OWIyYTM5ZiAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2 IEBACisyMDIwLTA0LTA2ICBGdWppaSBIaXJvbm9yaSAgPEhpcm9ub3JpLkZ1amlpQHNvbnkuY29t PgorCisgICAgICAgIFtDbGFuZyAxMF0gRml4IC1XaW1wbGljaXQtaW50LWZsb2F0LWNvbnZlcnNp b24gY29tcGlsYXRpb24gd2FybmluZ3MgaW4gVGVzdFdlYktpdEFQSQorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEwMDY3CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ2xhbmcgMTAgcmVwb3J0cyBhIGNvbXBp bGF0aW9uIHdhcm5pbmcgZm9yIGludCB0byBmbG9hdAorICAgICAgICBjb252ZXJzaW9ucyBsb3Np bmcgdGhlIHByZWNpc2lvbi4KKworICAgICAgICBUaGVyZSBhcmUgdGVzdCBjYXNlcyBmb3Igb3Zl cmZsb3csIG5vbi1vdmVyZmxvdywgdW5kZXJmbG93IGFuZAorICAgICAgICBub24tdW5kZXJmbG93 IGVkZ2UgY2FzZXMgaW4gV1RGLmNsYW1wVG9JbnRlZ2VyRmxvYXQgdGVzdC4KKyAgICAgICAgbWF4 UGx1c09uZTxpbnQ+IGNhbiBiZSB1c2VkIGZvciBvdmVyZmxvdyBlZGdlIGNhc2UsIElOVF9NSU4g Zm9yCisgICAgICAgIG5vbi11bmRlcmZsb3cuIFRoaXMgY2hhbmdlIGFkZGVkIGNvZGUgdG8gY2Fs Y3VsYXRlIHZhbHVlcyBmb3IKKyAgICAgICAgbm9uLW92ZXJmbG93IGFuZCB1bmRlcmZsb3cgY2Fz ZXMuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9NYXRoRXh0cmFzLmNwcDoK KyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QoV1RGLmNsYW1wVG9JbnRlZ2VyRmxvYXQpKToK KyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvRmxvYXRSZWN0LmNwcDoKKyAg ICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QoRmxvYXRSZWN0LkVuY2xvc2luZ0ludFJlY3QpKTog UmVwbGFjZWQKKyAgICAgICAgc2hpZnRNYXhYRWRnZVRvKElOVF9NQVgpIHdpdGggc2hpZnRNYXhY RWRnZVRvKDApIGJlY2F1c2UgaXQgYWxzbworICAgICAgICBjYXVzZXMgb3ZlcmZsb3cgZm9yIGVu Y2xvc2luZ0ludFJlY3QuCisKIDIwMjAtMDQtMDQgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2ll aEBhcHBsZS5jb20+CiAKICAgICAgICAgQWRkIGV2ZW4gbW9yZSBsb2dnaW5nIHRvIHRyeSBhbmQg ZGlhZ25vc2UgPHdlYmtpdC5vcmcvYi8yMDk2ODU+CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RzL1dURi9NYXRoRXh0cmFzLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV1RGL01hdGhFeHRyYXMuY3BwCmluZGV4IDY3NmQzNzVlOTQ2ZTVkY2EzNzJlOWY0ZTAxYjk4 ZGNlN2VmNTIzMWUuLjZmYWQ4MjA4ZTE4MTgzNDFjZWRlNDI3YWU3N2E3MDA5YTI3MTUyODQgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL01hdGhFeHRyYXMuY3BwCisr KyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL01hdGhFeHRyYXMuY3BwCkBAIC05Mywy MCArOTMsMjQgQEAgVEVTVChXVEYsIGNsYW1wVG9JbnRlZ2VyRmxvYXQpCiAgICAgLy8gVGhpcyB0 ZXN0IGlzIGluYWNjdXJhdGUgYXMgZmxvYXRzIHdpbGwgcm91bmQgdGhlIG1pbiAvIG1heCBpbnRl Z2VyCiAgICAgLy8gZHVlIHRvIHRoZSBuYXJyb3cgbWFudGlzc2EuIEhvd2V2ZXIgaXQgd2lsbCBw cm9wZXJseSBjaGVja3Mgd2l0aGluCiAgICAgLy8gKGNsb3NlIHRvIHRoZSBleHRyZW1lKSBhbmQg b3V0c2lkZSB0aGUgaW50ZWdlciByYW5nZS4KLSAgICBmbG9hdCBtYXhJbnQgPSBzdGQ6Om51bWVy aWNfbGltaXRzPGludD46Om1heCgpOworICAgIGZsb2F0IG92ZXJmbG93SW50ID0gbWF4UGx1c09u ZTxpbnQ+OworICAgIGZsb2F0IG1heEludCA9IG92ZXJmbG93SW50OworICAgIGZvciAoaW50IGkg PSAwOyBvdmVyZmxvd0ludCA9PSBtYXhJbnQ7IGkrKykKKyAgICAgICAgbWF4SW50ID0gb3ZlcmZs b3dJbnQgLSBpOworCiAgICAgZmxvYXQgbWluSW50ID0gc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+ OjptaW4oKTsKLSAgICBmbG9hdCBvdmVyZmxvd0ludCA9IG1heEludCAqIDEuMTsKLSAgICBmbG9h dCB1bmRlcmZsb3dJbnQgPSBtaW5JbnQgKiAxLjE7CisgICAgZmxvYXQgdW5kZXJmbG93SW50ID0g bWluSW50OworICAgIGZvciAoaW50IGkgPSAwOyB1bmRlcmZsb3dJbnQgPT0gbWluSW50OyBpKysp CisgICAgICAgIHVuZGVyZmxvd0ludCA9IG1pbkludCAtIGk7CiAKICAgICBFWFBFQ1RfR1Qob3Zl cmZsb3dJbnQsIG1heEludCk7CiAgICAgRVhQRUNUX0xUKHVuZGVyZmxvd0ludCwgbWluSW50KTsK IAotICAgIC8vIElmIG1heEludCA9PSAyXjMxIC0gMSAoaWUgb24gSTMyIGFyY2hpdGVjdHVyZSks IHRoZSBjbG9zZXN0IGZsb2F0IHVzZWQgdG8gcmVwcmVzZW50IGl0IGlzIDJeMzEuCi0gICAgRVhQ RUNUX05FQVIoY2xhbXBUb0ludGVnZXIobWF4SW50KSwgbWF4SW50LCAxKTsKLSAgICBFWFBFQ1Rf RVEoY2xhbXBUb0ludGVnZXIobWluSW50KSwgbWluSW50KTsKKyAgICBFWFBFQ1RfRVEoY2xhbXBU b0ludGVnZXIobWF4SW50KSwgc3RhdGljX2Nhc3Q8aW50PihtYXhJbnQpKTsKKyAgICBFWFBFQ1Rf RVEoY2xhbXBUb0ludGVnZXIobWluSW50KSwgc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+OjptaW4o KSk7CiAKLSAgICBFWFBFQ1RfTkVBUihjbGFtcFRvSW50ZWdlcihvdmVyZmxvd0ludCksIG1heElu dCwgMSk7Ci0gICAgRVhQRUNUX0VRKGNsYW1wVG9JbnRlZ2VyKHVuZGVyZmxvd0ludCksIG1pbklu dCk7CisgICAgRVhQRUNUX0VRKGNsYW1wVG9JbnRlZ2VyKG92ZXJmbG93SW50KSwgc3RkOjpudW1l cmljX2xpbWl0czxpbnQ+OjptYXgoKSk7CisgICAgRVhQRUNUX0VRKGNsYW1wVG9JbnRlZ2VyKHVu ZGVyZmxvd0ludCksIHN0ZDo6bnVtZXJpY19saW1pdHM8aW50Pjo6bWluKCkpOwogfQogCiBURVNU KFdURiwgY2xhbXBUb0ludGVnZXJEb3VibGUpCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYkNvcmUvRmxvYXRSZWN0LmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViQ29yZS9GbG9hdFJlY3QuY3BwCmluZGV4IGVmNmRiMDFlZmU2NjYxYmI2YmQ4ZmI3YjJh NDE0M2MxZGUzYzY4MWMuLjQ0Y2E4OTdkODA5OGZkYmE5ZmEwMGY4NzU4ZjFhZjRlMWEwNmY5YTYg MTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9GbG9hdFJlY3Qu Y3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9GbG9hdFJlY3QuY3Bw CkBAIC03NzAsOCArNzcwLDggQEAgVEVTVChGbG9hdFJlY3QsIEVuY2xvc2luZ0ludFJlY3QpCiAg ICAgRVhQRUNUX0VRKDc4OSwgZW5jbG9zZWQubWF4WSgpKTsKIAogICAgIFdlYkNvcmU6OkZsb2F0 UmVjdCBtYXhJbnRSZWN0KElOVF9NSU4sIElOVF9NSU4sIDAsIDApOwotICAgIG1heEludFJlY3Qu c2hpZnRNYXhYRWRnZVRvKElOVF9NQVgpOwotICAgIG1heEludFJlY3Quc2hpZnRNYXhZRWRnZVRv KElOVF9NQVgpOworICAgIG1heEludFJlY3Quc2hpZnRNYXhYRWRnZVRvKDApOworICAgIG1heElu dFJlY3Quc2hpZnRNYXhZRWRnZVRvKDApOwogCiAgICAgYXV0byBlbmNsb3NlZDIgPSBXZWJDb3Jl OjplbmNsb3NpbmdJbnRSZWN0KG1heEludFJlY3QpOwogCg== 395734 2020-04-07 13:54:42 -0700 2020-04-07 22:46:30 -0700 Patch for landing bug-210067-20200408055441.patch text/plain 3742 fujii U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5NTM3CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNWNjODJmNDllMzgwMzY4MDQwNjEwMDlhOTZmYjhmMDFl NzFkNmVlMC4uMmZmMjY0YWRmYjc4OTE3NjQwMTAyOGUzZjkxMDY3MGViNjc2ZmNmNSAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIz IEBACisyMDIwLTA0LTA2ICBGdWppaSBIaXJvbm9yaSAgPEhpcm9ub3JpLkZ1amlpQHNvbnkuY29t PgorCisgICAgICAgIFtDbGFuZyAxMF0gRml4IC1XaW1wbGljaXQtaW50LWZsb2F0LWNvbnZlcnNp b24gY29tcGlsYXRpb24gd2FybmluZ3MgaW4gVGVzdFdlYktpdEFQSQorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEwMDY3CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgVGhlcmUgYXJlIHRlc3QgY2FzZXMgZm9yIG92 ZXJmbG93LCBub24tb3ZlcmZsb3csIHVuZGVyZmxvdyBhbmQKKyAgICAgICAgbm9uLXVuZGVyZmxv dyBlZGdlIGNhc2VzIGluIFdURi5jbGFtcFRvSW50ZWdlckZsb2F0IHRlc3QuCisgICAgICAgIG1h eFBsdXNPbmU8aW50PiBjYW4gYmUgdXNlZCBmb3Igb3ZlcmZsb3cgZWRnZSBjYXNlLCBJTlRfTUlO IGZvcgorICAgICAgICBub24tdW5kZXJmbG93LiBUaGlzIGNoYW5nZSBhZGRlZCBjb2RlIHRvIGNh bGN1bGF0ZSB2YWx1ZXMgZm9yCisgICAgICAgIG5vbi1vdmVyZmxvdyBhbmQgdW5kZXJmbG93IGNh c2VzLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvTWF0aEV4dHJhcy5jcHA6 CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUKFdURi5jbGFtcFRvSW50ZWdlckZsb2F0KSk6 CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0Zsb2F0UmVjdC5jcHA6Cisg ICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUKEZsb2F0UmVjdC5FbmNsb3NpbmdJbnRSZWN0KSk6 IFJlcGxhY2VkCisgICAgICAgIHNoaWZ0TWF4WEVkZ2VUbyhJTlRfTUFYKSB3aXRoIHNoaWZ0TWF4 WEVkZ2VUbygwKSBiZWNhdXNlIGl0IGFsc28KKyAgICAgICAgY2F1c2VzIG92ZXJmbG93IGZvciBl bmNsb3NpbmdJbnRSZWN0LgorCiAyMDIwLTA0LTA0ICBXZW5zb24gSHNpZWggIDx3ZW5zb25faHNp ZWhAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBldmVuIG1vcmUgbG9nZ2luZyB0byB0cnkgYW5k IGRpYWdub3NlIDx3ZWJraXQub3JnL2IvMjA5Njg1PgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XVEYvTWF0aEV4dHJhcy5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RzL1dURi9NYXRoRXh0cmFzLmNwcAppbmRleCA2NzZkMzc1ZTk0NmU1ZGNhMzcyZTlmNGUwMWI5 OGRjZTdlZjUyMzFlLi42ZmFkODIwOGUxODE4MzQxY2VkZTQyN2FlNzdhNzAwOWEyNzE1Mjg0IDEw MDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9NYXRoRXh0cmFzLmNwcAor KysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9NYXRoRXh0cmFzLmNwcApAQCAtOTMs MjAgKzkzLDI0IEBAIFRFU1QoV1RGLCBjbGFtcFRvSW50ZWdlckZsb2F0KQogICAgIC8vIFRoaXMg dGVzdCBpcyBpbmFjY3VyYXRlIGFzIGZsb2F0cyB3aWxsIHJvdW5kIHRoZSBtaW4gLyBtYXggaW50 ZWdlcgogICAgIC8vIGR1ZSB0byB0aGUgbmFycm93IG1hbnRpc3NhLiBIb3dldmVyIGl0IHdpbGwg cHJvcGVybHkgY2hlY2tzIHdpdGhpbgogICAgIC8vIChjbG9zZSB0byB0aGUgZXh0cmVtZSkgYW5k IG91dHNpZGUgdGhlIGludGVnZXIgcmFuZ2UuCi0gICAgZmxvYXQgbWF4SW50ID0gc3RkOjpudW1l cmljX2xpbWl0czxpbnQ+OjptYXgoKTsKKyAgICBmbG9hdCBvdmVyZmxvd0ludCA9IG1heFBsdXNP bmU8aW50PjsKKyAgICBmbG9hdCBtYXhJbnQgPSBvdmVyZmxvd0ludDsKKyAgICBmb3IgKGludCBp ID0gMDsgb3ZlcmZsb3dJbnQgPT0gbWF4SW50OyBpKyspCisgICAgICAgIG1heEludCA9IG92ZXJm bG93SW50IC0gaTsKKwogICAgIGZsb2F0IG1pbkludCA9IHN0ZDo6bnVtZXJpY19saW1pdHM8aW50 Pjo6bWluKCk7Ci0gICAgZmxvYXQgb3ZlcmZsb3dJbnQgPSBtYXhJbnQgKiAxLjE7Ci0gICAgZmxv YXQgdW5kZXJmbG93SW50ID0gbWluSW50ICogMS4xOworICAgIGZsb2F0IHVuZGVyZmxvd0ludCA9 IG1pbkludDsKKyAgICBmb3IgKGludCBpID0gMDsgdW5kZXJmbG93SW50ID09IG1pbkludDsgaSsr KQorICAgICAgICB1bmRlcmZsb3dJbnQgPSBtaW5JbnQgLSBpOwogCiAgICAgRVhQRUNUX0dUKG92 ZXJmbG93SW50LCBtYXhJbnQpOwogICAgIEVYUEVDVF9MVCh1bmRlcmZsb3dJbnQsIG1pbkludCk7 CiAKLSAgICAvLyBJZiBtYXhJbnQgPT0gMl4zMSAtIDEgKGllIG9uIEkzMiBhcmNoaXRlY3R1cmUp LCB0aGUgY2xvc2VzdCBmbG9hdCB1c2VkIHRvIHJlcHJlc2VudCBpdCBpcyAyXjMxLgotICAgIEVY UEVDVF9ORUFSKGNsYW1wVG9JbnRlZ2VyKG1heEludCksIG1heEludCwgMSk7Ci0gICAgRVhQRUNU X0VRKGNsYW1wVG9JbnRlZ2VyKG1pbkludCksIG1pbkludCk7CisgICAgRVhQRUNUX0VRKGNsYW1w VG9JbnRlZ2VyKG1heEludCksIHN0YXRpY19jYXN0PGludD4obWF4SW50KSk7CisgICAgRVhQRUNU X0VRKGNsYW1wVG9JbnRlZ2VyKG1pbkludCksIHN0ZDo6bnVtZXJpY19saW1pdHM8aW50Pjo6bWlu KCkpOwogCi0gICAgRVhQRUNUX05FQVIoY2xhbXBUb0ludGVnZXIob3ZlcmZsb3dJbnQpLCBtYXhJ bnQsIDEpOwotICAgIEVYUEVDVF9FUShjbGFtcFRvSW50ZWdlcih1bmRlcmZsb3dJbnQpLCBtaW5J bnQpOworICAgIEVYUEVDVF9FUShjbGFtcFRvSW50ZWdlcihvdmVyZmxvd0ludCksIHN0ZDo6bnVt ZXJpY19saW1pdHM8aW50Pjo6bWF4KCkpOworICAgIEVYUEVDVF9FUShjbGFtcFRvSW50ZWdlcih1 bmRlcmZsb3dJbnQpLCBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1pbigpKTsKIH0KIAogVEVT VChXVEYsIGNsYW1wVG9JbnRlZ2VyRG91YmxlKQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJDb3JlL0Zsb2F0UmVjdC5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RzL1dlYkNvcmUvRmxvYXRSZWN0LmNwcAppbmRleCBlZjZkYjAxZWZlNjY2MWJiNmJkOGZiN2Iy YTQxNDNjMWRlM2M2ODFjLi4yOWJhNTVhOWRhYmYzOWMzMGY5ZjU3YWQ1M2RjZThjMWMzOWVhOGU4 IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvRmxvYXRSZWN0 LmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvRmxvYXRSZWN0LmNw cApAQCAtNzcwLDggKzc3MCw4IEBAIFRFU1QoRmxvYXRSZWN0LCBFbmNsb3NpbmdJbnRSZWN0KQog ICAgIEVYUEVDVF9FUSg3ODksIGVuY2xvc2VkLm1heFkoKSk7CiAKICAgICBXZWJDb3JlOjpGbG9h dFJlY3QgbWF4SW50UmVjdChJTlRfTUlOLCBJTlRfTUlOLCAwLCAwKTsKLSAgICBtYXhJbnRSZWN0 LnNoaWZ0TWF4WEVkZ2VUbyhJTlRfTUFYKTsKLSAgICBtYXhJbnRSZWN0LnNoaWZ0TWF4WUVkZ2VU byhJTlRfTUFYKTsKKyAgICBtYXhJbnRSZWN0LnNoaWZ0TWF4WEVkZ2VUbygzMCk7CisgICAgbWF4 SW50UmVjdC5zaGlmdE1heFlFZGdlVG8oMzApOwogCiAgICAgYXV0byBlbmNsb3NlZDIgPSBXZWJD b3JlOjplbmNsb3NpbmdJbnRSZWN0KG1heEludFJlY3QpOwogCg==