159609 2016-07-10 13:01:31 -0700 Relax ordering requirements on StringView::CodePoints iterator 2016-07-13 17:08:24 -0700 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=159710 P2 Normal --- 1 mmaxfield mmaxfield benjamin cdumez cmarcelo commit-queue darin dino jonlee simon.fraser thorton oldest_to_newest 1209550 0 mmaxfield 2016-07-10 13:01:31 -0700 Relax ordering requirements on StringView::CodePoints iterator 1209551 1 283290 mmaxfield 2016-07-10 13:02:38 -0700 Created attachment 283290 Patch 1209879 2 283365 mmaxfield 2016-07-11 16:47:28 -0700 Created attachment 283365 Patch 1209916 3 283365 darin 2016-07-11 19:27:09 -0700 Comment on attachment 283365 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=283365&action=review Seems OK, but can be coded a bit tighter. > Source/WTF/wtf/text/StringView.h:656 > + void advanceCurrentCodePoint(); I’d just call this “advance” or (see below) not have this function at all. > Source/WTF/wtf/text/StringView.h:660 > + unsigned m_index; > + unsigned m_indexEnd; We don’t need to add m_indexEnd. We can just change the meaning of m_index to have it point to the start of the next code point. Maybe rename it m_nextCodePointOffset. > Source/WTF/wtf/text/StringView.h:661 > + UChar32 m_currentCodePoint; Not sure this needs the word “current” in its name. We didn’t call it m_currentIndex. > Source/WTF/wtf/text/StringView.h:717 > + , m_indexEnd(index) As I said above, not needed. > Source/WTF/wtf/text/StringView.h:719 > + advanceCurrentCodePoint(); Could just write one of these lines here instead: ++*this; operator++(); Then we would not need a separate advanceCurrentCodePoint function. > Source/WTF/wtf/text/StringView.h:728 > + if (m_indexEnd == m_stringView.length()) { > + m_currentCodePoint = 0; > + return; > + } I’m not sure I understand the importance of this. Do we need a feature where we let you safely advance past the last character and return 0 for the current code point once you do that? Maybe an assertion instead? > Source/WTF/wtf/text/StringView.h:729 > + UChar32 result = 0; No need for the "= 0" here, both sides of the if below set the result. > Source/WTF/wtf/text/StringView.h:734 > + if (m_stringView.is8Bit()) > + result = m_stringView.characters8()[m_indexEnd++]; > + else > + U16_NEXT(m_stringView.characters16(), m_indexEnd, m_stringView.length(), result); > + m_currentCodePoint = result; We do not need "result". Just use m_currentCodePoint directly. > Source/WTF/wtf/text/StringView.h:739 > + advanceCurrentCodePoint(); We should be asserting here that m_nextCodePointOffset < m_stringView.length(). > Source/WTF/wtf/text/StringView.h:745 > + return m_currentCodePoint; Seems like we should be asserting here that m_nextCodePointOffset <= m_stringView.length(). > Source/WTF/wtf/text/StringView.h:752 > + ASSERT(!result || (m_indexEnd == other.m_indexEnd && m_currentCodePoint == other.m_currentCodePoint)); This assertion seems like overkill to me. Doesn’t really seem relevant to the job of comparing two iterators. 1209917 4 darin 2016-07-11 19:28:52 -0700 Not sure m_nextCodePointOffset is a good name. Maybe m_index is fine. 1210117 5 283365 mmaxfield 2016-07-12 11:47:50 -0700 Comment on attachment 283365 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=283365&action=review >> Source/WTF/wtf/text/StringView.h:660 >> + unsigned m_indexEnd; > > We don’t need to add m_indexEnd. We can just change the meaning of m_index to have it point to the start of the next code point. Maybe rename it m_nextCodePointOffset. The index of the current code point is necessary to make sure that an iterator which points to the last code point is distinct from end(). >> Source/WTF/wtf/text/StringView.h:728 >> + } > > I’m not sure I understand the importance of this. Do we need a feature where we let you safely advance past the last character and return 0 for the current code point once you do that? Maybe an assertion instead? This is how end() works. End represents just off the end of the StringView. 1210118 6 mmaxfield 2016-07-12 11:48:52 -0700 Committed r203119: <http://trac.webkit.org/changeset/203119> 1210160 7 283365 darin 2016-07-12 14:38:52 -0700 Comment on attachment 283365 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=283365&action=review >>> Source/WTF/wtf/text/StringView.h:660 >>> + unsigned m_indexEnd; >> >> We don’t need to add m_indexEnd. We can just change the meaning of m_index to have it point to the start of the next code point. Maybe rename it m_nextCodePointOffset. > > The index of the current code point is necessary to make sure that an iterator which points to the last code point is distinct from end(). Or we could just use a boolean for that, which I think would be clearer than having two index values. Or we could use a special index value for end(), such as 0xFFFFFFFF, which can never be an index into a StringView, since it’s more than the maximum string length. Or we could use Optional<unsigned> for the index. >>> Source/WTF/wtf/text/StringView.h:728 >>> + } >> >> I’m not sure I understand the importance of this. Do we need a feature where we let you safely advance past the last character and return 0 for the current code point once you do that? Maybe an assertion instead? > > This is how end() works. End represents just off the end of the StringView. Sure, but why set m_currentCodePoint since it’s illegal to look at it? 1210792 8 mmaxfield 2016-07-13 17:08:24 -0700 (In reply to comment #7) > Comment on attachment 283365 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=283365&action=review > > >>> Source/WTF/wtf/text/StringView.h:660 > >>> + unsigned m_indexEnd; > >> > >> We don’t need to add m_indexEnd. We can just change the meaning of m_index to have it point to the start of the next code point. Maybe rename it m_nextCodePointOffset. > > > > The index of the current code point is necessary to make sure that an iterator which points to the last code point is distinct from end(). > > Or we could just use a boolean for that, which I think would be clearer than > having two index values. Or we could use a special index value for end(), > such as 0xFFFFFFFF, which can never be an index into a StringView, since > it’s more than the maximum string length. Or we could use Optional<unsigned> > for the index. > > >>> Source/WTF/wtf/text/StringView.h:728 > >>> + } > >> > >> I’m not sure I understand the importance of this. Do we need a feature where we let you safely advance past the last character and return 0 for the current code point once you do that? Maybe an assertion instead? > > > > This is how end() works. End represents just off the end of the StringView. > > Sure, but why set m_currentCodePoint since it’s illegal to look at it? Updated in https://bugs.webkit.org/show_bug.cgi?id=159749 283290 2016-07-10 13:02:38 -0700 2016-07-11 16:47:24 -0700 Patch bug-159609-20160710130158.patch text/plain 6249 mmaxfield U3VidmVyc2lvbiBSZXZpc2lvbjogMjAzMDM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDAyZDAwNmI0YWNmZWM5OTZlMjcxNDQy MWVhZWI3OWVlNDJjMGQyZDAuLjA1NThlNmNlMGU2YzgxZmE5Yjk5ZDkyYTNjYjY5MTUxODU2YWNi YzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDUgKzEsMjIgQEAKIDIwMTYtMDctMTAgIE15bGVzIEMuIE1heGZpZWxkICA8 bW1heGZpZWxkQGFwcGxlLmNvbT4KIAorICAgICAgICBSZWxheCBvcmRlcmluZyByZXF1aXJlbWVu dHMgb24gU3RyaW5nVmlldzo6Q29kZVBvaW50cyBpdGVyYXRvcgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTU5NjA5CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUHJldmlvdXNseSwgdGhlcmUgd2FzIGEgcmVx dWlyZW1lbnQgd2hlcmUgaWYgeW91IHVzZSBhIENvZGVQb2ludHMKKyAgICAgICAgaXRlcmF0b3Is IHlvdSBjb3VsZG4ndCBkZXJlZmVyZW5jZSB0d2ljZSBpbiBhIHJvdyBvciBpbmNyZW1lbnQKKyAg ICAgICAgdHdpY2UgaW4gYSByb3cuIFRoaXMgcmVzdHJpY3Rpb24gaXMgdW5uZWNlc3NhcnkuCisK KyAgICAgICAgKiB3dGYvdGV4dC9TdHJpbmdWaWV3Lmg6CisgICAgICAgIChXVEY6OlN0cmluZ1Zp ZXc6OkNvZGVQb2ludHM6Okl0ZXJhdG9yOjpJdGVyYXRvcik6CisgICAgICAgIChXVEY6OlN0cmlu Z1ZpZXc6OkNvZGVQb2ludHM6Okl0ZXJhdG9yOjphZHZhbmNlQ3VycmVudENvZGVQb2ludCk6Cisg ICAgICAgIChXVEY6OlN0cmluZ1ZpZXc6OkNvZGVQb2ludHM6Okl0ZXJhdG9yOjpvcGVyYXRvciop OgorICAgICAgICAoV1RGOjpTdHJpbmdWaWV3OjpDb2RlUG9pbnRzOjpJdGVyYXRvcjo6b3BlcmF0 b3I9PSk6CisKKzIwMTYtMDctMTAgIE15bGVzIEMuIE1heGZpZWxkICA8bW1heGZpZWxkQGFwcGxl LmNvbT4KKwogICAgICAgICBNb3ZlIGJyZWFraW5nIGl0ZXJhdG9yIGNvZGUgdG8gV1RGCiAgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNTk1OTQKIApkaWZm IC0tZ2l0IGEvU291cmNlL1dURi93dGYvdGV4dC9TdHJpbmdWaWV3LmggYi9Tb3VyY2UvV1RGL3d0 Zi90ZXh0L1N0cmluZ1ZpZXcuaAppbmRleCAzYWVmNGRiYmY4OTQ3ZmRhYTE4NTc0MmY4YTkyN2E3 NDkzOWUwODJlLi44MjYwODg4YTgzMDMyNjI4ZDZiMjFkMDViMjU1YmU4ZGMwNjcxODcwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi90ZXh0L1N0cmluZ1ZpZXcuaAorKysgYi9Tb3VyY2UvV1RG L3d0Zi90ZXh0L1N0cmluZ1ZpZXcuaApAQCAtNjE1LDExICs2MTUsMTIgQEAgcHVibGljOgogICAg IGJvb2wgb3BlcmF0b3IhPShjb25zdCBJdGVyYXRvciYpIGNvbnN0OwogCiBwcml2YXRlOgorICAg IHZvaWQgYWR2YW5jZUN1cnJlbnRDb2RlUG9pbnQoKTsKKwogICAgIGNvbnN0IFN0cmluZ1ZpZXcm IG1fc3RyaW5nVmlldzsKLSAgICBtdXRhYmxlIHVuc2lnbmVkIG1faW5kZXg7Ci0jaWYgIUFTU0VS VF9ESVNBQkxFRAotICAgIG11dGFibGUgYm9vbCBtX2FscmVhZHlJbmNyZW1lbnRlZCB7IGZhbHNl IH07Ci0jZW5kaWYKKyAgICB1bnNpZ25lZCBtX2luZGV4OworICAgIHVuc2lnbmVkIG1faW5kZXhF bmQ7CisgICAgVUNoYXIzMiBtX2N1cnJlbnRDb2RlUG9pbnQ7CiB9OwogCiBjbGFzcyBTdHJpbmdW aWV3OjpDb2RlVW5pdHM6Okl0ZXJhdG9yIHsKQEAgLTY1NSwzOCArNjU2LDQzIEBAIGlubGluZSBT dHJpbmdWaWV3OjpDb2RlUG9pbnRzOjpDb2RlUG9pbnRzKGNvbnN0IFN0cmluZ1ZpZXcmIHN0cmlu Z1ZpZXcpCiBpbmxpbmUgU3RyaW5nVmlldzo6Q29kZVBvaW50czo6SXRlcmF0b3I6Okl0ZXJhdG9y KGNvbnN0IFN0cmluZ1ZpZXcmIHN0cmluZ1ZpZXcsIHVuc2lnbmVkIGluZGV4KQogICAgIDogbV9z dHJpbmdWaWV3KHN0cmluZ1ZpZXcpCiAgICAgLCBtX2luZGV4KGluZGV4KQorICAgICwgbV9pbmRl eEVuZChpbmRleCkKIHsKKyAgICBhZHZhbmNlQ3VycmVudENvZGVQb2ludCgpOworfQorCitpbmxp bmUgdm9pZCBTdHJpbmdWaWV3OjpDb2RlUG9pbnRzOjpJdGVyYXRvcjo6YWR2YW5jZUN1cnJlbnRD b2RlUG9pbnQoKQoreworICAgIG1faW5kZXggPSBtX2luZGV4RW5kOworICAgIGlmIChtX2luZGV4 RW5kID09IG1fc3RyaW5nVmlldy5sZW5ndGgoKSkgeworICAgICAgICBtX2N1cnJlbnRDb2RlUG9p bnQgPSAwOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIFVDaGFyMzIgcmVzdWx0ID0gMDsK KyAgICBpZiAobV9zdHJpbmdWaWV3LmlzOEJpdCgpKQorICAgICAgICByZXN1bHQgPSBtX3N0cmlu Z1ZpZXcuY2hhcmFjdGVyczgoKVttX2luZGV4RW5kKytdOworICAgIGVsc2UKKyAgICAgICAgVTE2 X05FWFQobV9zdHJpbmdWaWV3LmNoYXJhY3RlcnMxNigpLCBtX2luZGV4RW5kLCBtX3N0cmluZ1Zp ZXcubGVuZ3RoKCksIHJlc3VsdCk7CisgICAgbV9jdXJyZW50Q29kZVBvaW50ID0gcmVzdWx0Owog fQogCiBpbmxpbmUgYXV0byBTdHJpbmdWaWV3OjpDb2RlUG9pbnRzOjpJdGVyYXRvcjo6b3BlcmF0 b3IrKygpIC0+IEl0ZXJhdG9yJgogewotI2lmICFBU1NFUlRfRElTQUJMRUQKLSAgICBBU1NFUlQo bV9hbHJlYWR5SW5jcmVtZW50ZWQpOwotICAgIG1fYWxyZWFkeUluY3JlbWVudGVkID0gZmFsc2U7 Ci0jZW5kaWYKKyAgICBhZHZhbmNlQ3VycmVudENvZGVQb2ludCgpOwogICAgIHJldHVybiAqdGhp czsKIH0KIAogaW5saW5lIFVDaGFyMzIgU3RyaW5nVmlldzo6Q29kZVBvaW50czo6SXRlcmF0b3I6 Om9wZXJhdG9yKigpIGNvbnN0CiB7Ci0jaWYgIUFTU0VSVF9ESVNBQkxFRAotICAgIEFTU0VSVCgh bV9hbHJlYWR5SW5jcmVtZW50ZWQpOwotICAgIG1fYWxyZWFkeUluY3JlbWVudGVkID0gdHJ1ZTsK LSNlbmRpZgotCi0gICAgaWYgKG1fc3RyaW5nVmlldy5pczhCaXQoKSkKLSAgICAgICAgcmV0dXJu IG1fc3RyaW5nVmlldy5jaGFyYWN0ZXJzOCgpW21faW5kZXgrK107Ci0KLSAgICBVQ2hhcjMyIGNv ZGVQb2ludDsKLSAgICBVMTZfTkVYVChtX3N0cmluZ1ZpZXcuY2hhcmFjdGVyczE2KCksIG1faW5k ZXgsIG1fc3RyaW5nVmlldy5sZW5ndGgoKSwgY29kZVBvaW50KTsKLSAgICByZXR1cm4gY29kZVBv aW50OworICAgIHJldHVybiBtX2N1cnJlbnRDb2RlUG9pbnQ7CiB9CiAKIGlubGluZSBib29sIFN0 cmluZ1ZpZXc6OkNvZGVQb2ludHM6Okl0ZXJhdG9yOjpvcGVyYXRvcj09KGNvbnN0IEl0ZXJhdG9y JiBvdGhlcikgY29uc3QKIHsKICAgICBBU1NFUlQoJm1fc3RyaW5nVmlldyA9PSAmb3RoZXIubV9z dHJpbmdWaWV3KTsKLSAgICBBU1NFUlQoIW1fYWxyZWFkeUluY3JlbWVudGVkKTsKLSAgICByZXR1 cm4gbV9pbmRleCA9PSBvdGhlci5tX2luZGV4OworICAgIGJvb2wgcmVzdWx0ID0gbV9pbmRleCA9 PSBvdGhlci5tX2luZGV4OworICAgIGFzc2VydCghcmVzdWx0IHx8IChtX2luZGV4RW5kID09IG90 aGVyLm1faW5kZXhFbmQgJiYgbV9jdXJyZW50Q29kZVBvaW50ID09IG90aGVyLm1fY3VycmVudENv ZGVQb2ludCkpOworICAgIHJldHVybiByZXN1bHQ7CiB9CiAKIGlubGluZSBib29sIFN0cmluZ1Zp ZXc6OkNvZGVQb2ludHM6Okl0ZXJhdG9yOjpvcGVyYXRvciE9KGNvbnN0IEl0ZXJhdG9yJiBvdGhl cikgY29uc3QKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwpp bmRleCA3NWY3ZWYyN2JiYTFkNzBmMWYwOTIzNTZiYjFkYzI4YWVjYzkyYjAyLi44OTc3NjAzMGYx MDRhZjMyNjNiNDRkZWVkOGZjM2U1Yzk0NjBhZjQ4IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VM b2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTYtMDctMTAgIE15 bGVzIEMuIE1heGZpZWxkICA8bW1heGZpZWxkQGFwcGxlLmNvbT4KKworICAgICAgICBSZWxheCBv cmRlcmluZyByZXF1aXJlbWVudHMgb24gU3RyaW5nVmlldzo6Q29kZVBvaW50cyBpdGVyYXRvcgor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTU5NjA5CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBUZXN0V2Vi S2l0QVBJL1Rlc3RzL1dURi9TdHJpbmdWaWV3LmNwcDoKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6 OlRFU1QpOgorCiAyMDE2LTA3LTA5ICBEYW4gQmVybnN0ZWluICA8bWl0ekBhcHBsZS5jb20+CiAK ICAgICAgICAgR2l2ZSBnaXQtYWRkLXJldmlld2VyIGFuIG9wdGlvbiB0byBzYXkg4oCcUnViYmVy LXN0YW1wZWQgYnnigJ0gaW4gbm9uLWludGVyYWN0aXZlIG1vZGUKZGlmZiAtLWdpdCBhL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1N0cmluZ1ZpZXcuY3BwIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XVEYvU3RyaW5nVmlldy5jcHAKaW5kZXggNDA4Y2M2NDJlYjc2MTc5ODBhYjQ2 ZjgwZjU0NTZlMzI4ZWY2MDJmMC4uNzM1ZmM4NjJjM2VlZWRlNDI4NWMxYmZjOWM1ODM4YTZiMjRk MGQzYSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvU3RyaW5nVmll dy5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvU3RyaW5nVmlldy5jcHAK QEAgLTEwMywxNCArMTAzLDI0IEBAIHN0YXRpYyB2b2lkIGJ1aWxkKFN0cmluZ0J1aWxkZXImIGJ1 aWxkZXIsIHN0ZDo6dmVjdG9yPFVDaGFyPiBpbnB1dCkKIAogVEVTVChXVEYsIFN0cmluZ1ZpZXdJ dGVyYXRvcnMpCiB7Ci0gICAgY29tcGFyZUxvb3BJdGVyYXRpb25zKFN0cmluZ1ZpZXcoKS5jb2Rl UG9pbnRzKCksIHsgfSk7Ci0gICAgY29tcGFyZUxvb3BJdGVyYXRpb25zKFN0cmluZ1ZpZXcoKS5j b2RlVW5pdHMoKSwgeyB9KTsKLQotICAgIGNvbXBhcmVMb29wSXRlcmF0aW9ucyhTdHJpbmdWaWV3 OjplbXB0eSgpLmNvZGVQb2ludHMoKSwgeyB9KTsKLSAgICBjb21wYXJlTG9vcEl0ZXJhdGlvbnMo U3RyaW5nVmlldzo6ZW1wdHkoKS5jb2RlVW5pdHMoKSwgeyB9KTsKLQotICAgIGNvbXBhcmVMb29w SXRlcmF0aW9ucyhTdHJpbmdWaWV3KFN0cmluZygiaGVsbG8iKSkuY29kZVBvaW50cygpLCB7J2gn LCAnZScsICdsJywgJ2wnLCAnbyd9KTsKLSAgICBjb21wYXJlTG9vcEl0ZXJhdGlvbnMoU3RyaW5n VmlldyhTdHJpbmcoImhlbGxvIikpLmNvZGVVbml0cygpLCB7J2gnLCAnZScsICdsJywgJ2wnLCAn byd9KTsKKyAgICAvLyBNYWtlIHN1cmUgZHVwbGljYXRlIGRlcmVmZXJlbmNlIGFuZCBpbmNyZW1l bnQgb3BlcmF0b3JzIHdvcmsKKyAgICBTdHJpbmcgaGVsbygiaGVsbyIpOworICAgIFN0cmluZ1Zp ZXcgaGVsb1ZpZXcoaGVsbyk7CisgICAgYXV0byBjb2RlUG9pbnRzSXRlcmF0b3IgPSBoZWxvVmll dy5jb2RlVW5pdHMoKS5iZWdpbigpOworICAgIEVYUEVDVF9FUSgqY29kZVBvaW50c0l0ZXJhdG9y LCAnaCcpOworICAgIEVYUEVDVF9FUSgqY29kZVBvaW50c0l0ZXJhdG9yLCAnaCcpOworICAgICsr Y29kZVBvaW50c0l0ZXJhdG9yOworICAgICsrY29kZVBvaW50c0l0ZXJhdG9yOworICAgIEVYUEVD VF9FUSgqY29kZVBvaW50c0l0ZXJhdG9yLCAnbCcpOworCisgICAgRVhQRUNUX1RSVUUoY29tcGFy ZUxvb3BJdGVyYXRpb25zKFN0cmluZ1ZpZXcoKS5jb2RlUG9pbnRzKCksIHsgfSkpOworICAgIEVY UEVDVF9UUlVFKGNvbXBhcmVMb29wSXRlcmF0aW9ucyhTdHJpbmdWaWV3KCkuY29kZVVuaXRzKCks IHsgfSkpOworCisgICAgRVhQRUNUX1RSVUUoY29tcGFyZUxvb3BJdGVyYXRpb25zKFN0cmluZ1Zp ZXc6OmVtcHR5KCkuY29kZVBvaW50cygpLCB7IH0pKTsKKyAgICBFWFBFQ1RfVFJVRShjb21wYXJl TG9vcEl0ZXJhdGlvbnMoU3RyaW5nVmlldzo6ZW1wdHkoKS5jb2RlVW5pdHMoKSwgeyB9KSk7CisK KyAgICBFWFBFQ1RfVFJVRShjb21wYXJlTG9vcEl0ZXJhdGlvbnMoU3RyaW5nVmlldyhTdHJpbmco ImhlbGxvIikpLmNvZGVQb2ludHMoKSwgeydoJywgJ2UnLCAnbCcsICdsJywgJ28nfSkpOworICAg IEVYUEVDVF9UUlVFKGNvbXBhcmVMb29wSXRlcmF0aW9ucyhTdHJpbmdWaWV3KFN0cmluZygiaGVs bG8iKSkuY29kZVVuaXRzKCksIHsnaCcsICdlJywgJ2wnLCAnbCcsICdvJ30pKTsKIAogICAgIFN0 cmluZ0J1aWxkZXIgYjsKICAgICBidWlsZChiLCB7MHhEODAwLCAweERENTV9KTsgLy8gU3Vycm9n YXRlcyBmb3IgdW5pY29kZSBjb2RlIHBvaW50IFUrMTAxNTUK 283365 2016-07-11 16:47:28 -0700 2016-07-11 19:27:09 -0700 Patch bug-159609-20160711164645.patch text/plain 5277 mmaxfield U3VidmVyc2lvbiBSZXZpc2lvbjogMjAzMDk1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDhmOGQ3MTI5NWNmZTMwYmVkZWYyNTE4 NzIxOWU1NWY5ZTJkM2M2OGEuLmNiMDFhMWEzZGZkYTIyN2E4ODVjZTk4ZDgwOTY2OTQzZDc0MGUx NWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDUgKzEsMjIgQEAKIDIwMTYtMDctMTEgIE15bGVzIEMuIE1heGZpZWxkICA8 bW1heGZpZWxkQGFwcGxlLmNvbT4KIAorICAgICAgICBSZWxheCBvcmRlcmluZyByZXF1aXJlbWVu dHMgb24gU3RyaW5nVmlldzo6Q29kZVBvaW50cyBpdGVyYXRvcgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTU5NjA5CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUHJldmlvdXNseSwgdGhlcmUgd2FzIGEgcmVx dWlyZW1lbnQgd2hlcmUgaWYgeW91IHVzZSBhIENvZGVQb2ludHMKKyAgICAgICAgaXRlcmF0b3Is IHlvdSBjb3VsZG4ndCBkZXJlZmVyZW5jZSB0d2ljZSBpbiBhIHJvdyBvciBpbmNyZW1lbnQKKyAg ICAgICAgdHdpY2UgaW4gYSByb3cuIFRoaXMgcmVzdHJpY3Rpb24gaXMgdW5uZWNlc3NhcnkuCisK KyAgICAgICAgKiB3dGYvdGV4dC9TdHJpbmdWaWV3Lmg6CisgICAgICAgIChXVEY6OlN0cmluZ1Zp ZXc6OkNvZGVQb2ludHM6Okl0ZXJhdG9yOjpJdGVyYXRvcik6CisgICAgICAgIChXVEY6OlN0cmlu Z1ZpZXc6OkNvZGVQb2ludHM6Okl0ZXJhdG9yOjphZHZhbmNlQ3VycmVudENvZGVQb2ludCk6Cisg ICAgICAgIChXVEY6OlN0cmluZ1ZpZXc6OkNvZGVQb2ludHM6Okl0ZXJhdG9yOjpvcGVyYXRvciop OgorICAgICAgICAoV1RGOjpTdHJpbmdWaWV3OjpDb2RlUG9pbnRzOjpJdGVyYXRvcjo6b3BlcmF0 b3I9PSk6CisKKzIwMTYtMDctMTEgIE15bGVzIEMuIE1heGZpZWxkICA8bW1heGZpZWxkQGFwcGxl LmNvbT4KKwogICAgICAgICBJbXBsZW1lbnQgZ3JhcGhlbWUgY2x1c3RlciBpdGVyYXRvciBvbiBT dHJpbmdWaWV3CiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0xNTk1OTgKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvdGV4dC9TdHJpbmdWaWV3Lmgg Yi9Tb3VyY2UvV1RGL3d0Zi90ZXh0L1N0cmluZ1ZpZXcuaAppbmRleCAzYmYwY2VmMmEwMGQ0MzM3 OGEzNWYxZjYxZGU1YTkzNmZkZDY2ZGEzLi42ZDkxOGE5ZGNhYjVkZWYwN2I5NzUzNjdjMTEwZDc4 OGY5Zjc3Njc0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi90ZXh0L1N0cmluZ1ZpZXcuaAor KysgYi9Tb3VyY2UvV1RGL3d0Zi90ZXh0L1N0cmluZ1ZpZXcuaApAQCAtNjUzLDExICs2NTMsMTIg QEAgcHVibGljOgogICAgIGJvb2wgb3BlcmF0b3IhPShjb25zdCBJdGVyYXRvciYpIGNvbnN0Owog CiBwcml2YXRlOgorICAgIHZvaWQgYWR2YW5jZUN1cnJlbnRDb2RlUG9pbnQoKTsKKwogICAgIGNv bnN0IFN0cmluZ1ZpZXcmIG1fc3RyaW5nVmlldzsKLSAgICBtdXRhYmxlIHVuc2lnbmVkIG1faW5k ZXg7Ci0jaWYgIUFTU0VSVF9ESVNBQkxFRAotICAgIG11dGFibGUgYm9vbCBtX2FscmVhZHlJbmNy ZW1lbnRlZCB7IGZhbHNlIH07Ci0jZW5kaWYKKyAgICB1bnNpZ25lZCBtX2luZGV4OworICAgIHVu c2lnbmVkIG1faW5kZXhFbmQ7CisgICAgVUNoYXIzMiBtX2N1cnJlbnRDb2RlUG9pbnQ7CiB9Owog CiBjbGFzcyBTdHJpbmdWaWV3OjpDb2RlVW5pdHM6Okl0ZXJhdG9yIHsKQEAgLTcxMywzOCArNzE0 LDQzIEBAIGlubGluZSBTdHJpbmdWaWV3OjpDb2RlUG9pbnRzOjpDb2RlUG9pbnRzKGNvbnN0IFN0 cmluZ1ZpZXcmIHN0cmluZ1ZpZXcpCiBpbmxpbmUgU3RyaW5nVmlldzo6Q29kZVBvaW50czo6SXRl cmF0b3I6Okl0ZXJhdG9yKGNvbnN0IFN0cmluZ1ZpZXcmIHN0cmluZ1ZpZXcsIHVuc2lnbmVkIGlu ZGV4KQogICAgIDogbV9zdHJpbmdWaWV3KHN0cmluZ1ZpZXcpCiAgICAgLCBtX2luZGV4KGluZGV4 KQorICAgICwgbV9pbmRleEVuZChpbmRleCkKIHsKKyAgICBhZHZhbmNlQ3VycmVudENvZGVQb2lu dCgpOworfQorCitpbmxpbmUgdm9pZCBTdHJpbmdWaWV3OjpDb2RlUG9pbnRzOjpJdGVyYXRvcjo6 YWR2YW5jZUN1cnJlbnRDb2RlUG9pbnQoKQoreworICAgIG1faW5kZXggPSBtX2luZGV4RW5kOwor ICAgIGlmIChtX2luZGV4RW5kID09IG1fc3RyaW5nVmlldy5sZW5ndGgoKSkgeworICAgICAgICBt X2N1cnJlbnRDb2RlUG9pbnQgPSAwOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIFVDaGFy MzIgcmVzdWx0ID0gMDsKKyAgICBpZiAobV9zdHJpbmdWaWV3LmlzOEJpdCgpKQorICAgICAgICBy ZXN1bHQgPSBtX3N0cmluZ1ZpZXcuY2hhcmFjdGVyczgoKVttX2luZGV4RW5kKytdOworICAgIGVs c2UKKyAgICAgICAgVTE2X05FWFQobV9zdHJpbmdWaWV3LmNoYXJhY3RlcnMxNigpLCBtX2luZGV4 RW5kLCBtX3N0cmluZ1ZpZXcubGVuZ3RoKCksIHJlc3VsdCk7CisgICAgbV9jdXJyZW50Q29kZVBv aW50ID0gcmVzdWx0OwogfQogCiBpbmxpbmUgYXV0byBTdHJpbmdWaWV3OjpDb2RlUG9pbnRzOjpJ dGVyYXRvcjo6b3BlcmF0b3IrKygpIC0+IEl0ZXJhdG9yJgogewotI2lmICFBU1NFUlRfRElTQUJM RUQKLSAgICBBU1NFUlQobV9hbHJlYWR5SW5jcmVtZW50ZWQpOwotICAgIG1fYWxyZWFkeUluY3Jl bWVudGVkID0gZmFsc2U7Ci0jZW5kaWYKKyAgICBhZHZhbmNlQ3VycmVudENvZGVQb2ludCgpOwog ICAgIHJldHVybiAqdGhpczsKIH0KIAogaW5saW5lIFVDaGFyMzIgU3RyaW5nVmlldzo6Q29kZVBv aW50czo6SXRlcmF0b3I6Om9wZXJhdG9yKigpIGNvbnN0CiB7Ci0jaWYgIUFTU0VSVF9ESVNBQkxF RAotICAgIEFTU0VSVCghbV9hbHJlYWR5SW5jcmVtZW50ZWQpOwotICAgIG1fYWxyZWFkeUluY3Jl bWVudGVkID0gdHJ1ZTsKLSNlbmRpZgotCi0gICAgaWYgKG1fc3RyaW5nVmlldy5pczhCaXQoKSkK LSAgICAgICAgcmV0dXJuIG1fc3RyaW5nVmlldy5jaGFyYWN0ZXJzOCgpW21faW5kZXgrK107Ci0K LSAgICBVQ2hhcjMyIGNvZGVQb2ludDsKLSAgICBVMTZfTkVYVChtX3N0cmluZ1ZpZXcuY2hhcmFj dGVyczE2KCksIG1faW5kZXgsIG1fc3RyaW5nVmlldy5sZW5ndGgoKSwgY29kZVBvaW50KTsKLSAg ICByZXR1cm4gY29kZVBvaW50OworICAgIHJldHVybiBtX2N1cnJlbnRDb2RlUG9pbnQ7CiB9CiAK IGlubGluZSBib29sIFN0cmluZ1ZpZXc6OkNvZGVQb2ludHM6Okl0ZXJhdG9yOjpvcGVyYXRvcj09 KGNvbnN0IEl0ZXJhdG9yJiBvdGhlcikgY29uc3QKIHsKICAgICBBU1NFUlQoJm1fc3RyaW5nVmll dyA9PSAmb3RoZXIubV9zdHJpbmdWaWV3KTsKLSAgICBBU1NFUlQoIW1fYWxyZWFkeUluY3JlbWVu dGVkKTsKLSAgICByZXR1cm4gbV9pbmRleCA9PSBvdGhlci5tX2luZGV4OworICAgIGJvb2wgcmVz dWx0ID0gbV9pbmRleCA9PSBvdGhlci5tX2luZGV4OworICAgIEFTU0VSVCghcmVzdWx0IHx8ICht X2luZGV4RW5kID09IG90aGVyLm1faW5kZXhFbmQgJiYgbV9jdXJyZW50Q29kZVBvaW50ID09IG90 aGVyLm1fY3VycmVudENvZGVQb2ludCkpOworICAgIHJldHVybiByZXN1bHQ7CiB9CiAKIGlubGlu ZSBib29sIFN0cmluZ1ZpZXc6OkNvZGVQb2ludHM6Okl0ZXJhdG9yOjpvcGVyYXRvciE9KGNvbnN0 IEl0ZXJhdG9yJiBvdGhlcikgY29uc3QKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rv b2xzL0NoYW5nZUxvZwppbmRleCAwYWZjMTRlMmE1YzdlYWExZDk0ZGViNDE1NjViMzc4OWFhMDMw ZWUzLi4wMDNkMDVjMmFjMWM5YzRiZDM2ZTUxZmRlNTVjZWI1MmRiMWRhNDUwIDEwMDY0NAotLS0g YS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAK KzIwMTYtMDctMTEgIE15bGVzIEMuIE1heGZpZWxkICA8bW1heGZpZWxkQGFwcGxlLmNvbT4KKwor ICAgICAgICBSZWxheCBvcmRlcmluZyByZXF1aXJlbWVudHMgb24gU3RyaW5nVmlldzo6Q29kZVBv aW50cyBpdGVyYXRvcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTU5NjA5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9TdHJpbmdWaWV3LmNwcDoKKyAgICAgICAg KFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDE2LTA3LTExICBKYXNvbiBNYXJjZWxsICA8am1h cmNlbGxAYXBwbGUuY29tPgogCiAgICAgICAgIFNWTi5jcmVhdGVfcGF0Y2ggc2hvdWxkIGZpbmQg c3ZuLWNyZWF0ZS1wYXRjaCByZWxhdGl2ZSB0byB0aGUgV2ViS2l0IHJvb3QuCmRpZmYgLS1naXQg YS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9TdHJpbmdWaWV3LmNwcCBiL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvV1RGL1N0cmluZ1ZpZXcuY3BwCmluZGV4IGNmYWMwYjdkMmYwM2Q0 ZTAyMGMwZDMyZTdmMzAyZTEyZDg1YzZjYmYuLmUyOGMyNGExOTljYTg4ZjQwZWFlN2ViOTQ2ZGY2 NDU4YTMxZTc0MTcgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1N0 cmluZ1ZpZXcuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1N0cmluZ1Zp ZXcuY3BwCkBAIC0xMjIsNiArMTIyLDEzIEBAIFRFU1QoV1RGLCBTdHJpbmdWaWV3SXRlcmF0b3Jz KQogICAgIFN0cmluZyBoZWxvKCJoZWxvIik7CiAgICAgU3RyaW5nVmlldyBoZWxvVmlldyhoZWxv KTsKIAorICAgIGF1dG8gY29kZVBvaW50c0l0ZXJhdG9yID0gaGVsb1ZpZXcuY29kZVVuaXRzKCku YmVnaW4oKTsKKyAgICBFWFBFQ1RfRVEoKmNvZGVQb2ludHNJdGVyYXRvciwgJ2gnKTsKKyAgICBF WFBFQ1RfRVEoKmNvZGVQb2ludHNJdGVyYXRvciwgJ2gnKTsKKyAgICArK2NvZGVQb2ludHNJdGVy YXRvcjsKKyAgICArK2NvZGVQb2ludHNJdGVyYXRvcjsKKyAgICBFWFBFQ1RfRVEoKmNvZGVQb2lu dHNJdGVyYXRvciwgJ2wnKTsKKwogICAgIEVYUEVDVF9UUlVFKGNvbXBhcmVMb29wSXRlcmF0aW9u cyhoZWxvVmlldy5jb2RlUG9pbnRzKCksIHsnaCcsICdlJywgJ2wnLCAnbyd9KSk7CiAgICAgRVhQ RUNUX1RSVUUoY29tcGFyZUxvb3BJdGVyYXRpb25zKGhlbG9WaWV3LmNvZGVVbml0cygpLCB7J2gn LCAnZScsICdsJywgJ28nfSkpOwogICAgIEVYUEVDVF9UUlVFKGNvbXBhcmVMb29wSXRlcmF0aW9u cyhoZWxvVmlldy5ncmFwaGVtZUNsdXN0ZXJzKCksIHsK