109784 2013-02-13 22:16:43 -0800 String(Vector) behaves differently from String(vector.data(), vector.size()) for vectors with inline capacity in the size=0 case 2013-02-14 12:03:33 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 109638 1 eric eric abarth andersca benjamin cmarcelo darin mjs msaboff ojan.autocc webkit.review.bot oldest_to_newest 832731 0 eric 2013-02-13 22:16:43 -0800 REGRESSION(r142712): attribute values show up as "(null)" instead of null with the threaded parser 832735 1 188263 eric 2013-02-13 22:23:22 -0800 Created attachment 188263 Patch 832736 2 eric 2013-02-13 22:24:27 -0800 I stab you in the face, visual studio. 832738 3 eric 2013-02-13 22:29:28 -0800 I've asked on webkit-dev about the sln issue: https://lists.webkit.org/pipermail/webkit-dev/2013-February/023844.html 832757 4 188263 benjamin 2013-02-13 23:21:55 -0800 Comment on attachment 188263 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=188263&action=review > Source/WTF/wtf/text/WTFString.h:115 > + // If the Vector is size == 0, this will produce an empty string. > template<size_t inlineCapacity> > explicit String(const Vector<UChar, inlineCapacity>&); Ouch. I considered changing adopt() to work the other way around. It will also mean String(vector) != String(vector.data(), vector.size()), which is counter-intuitive in my opinion. Why do you think empty() is the correct output? Shouldn't the specific call site be changed instead? Is 832807 5 eric 2013-02-14 01:02:02 -0800 (In reply to comment #4) > (From update of attachment 188263 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=188263&action=review > > > Source/WTF/wtf/text/WTFString.h:115 > > + // If the Vector is size == 0, this will produce an empty string. > > template<size_t inlineCapacity> > > explicit String(const Vector<UChar, inlineCapacity>&); > > Ouch. > I considered changing adopt() to work the other way around. > > It will also mean String(vector) != String(vector.data(), vector.size()), which is counter-intuitive in my opinion. String(UChar*, size_t) already returns the empty string when size ==0: // Construct a string with UTF-16 data. String::String(const UChar* characters, unsigned length) : m_impl(characters ? StringImpl::create(characters, length) : 0) { } So this change makes the behavior consistent. That was infact the bug. I changed callsites which used to use String(vector.data(), vector.size()) to use String(vector) and tests started failing (for the threaded parser). This patch fixes that. > Why do you think empty() is the correct output? Vector has no concept of null. I'm really just trying to make String(vector) match String(vector.data(), vector.size()), since that seems to me they should match. :) > Shouldn't the specific call site be changed instead? see above. 832810 6 benjamin 2013-02-14 01:05:32 -0800 > > It will also mean String(vector) != String(vector.data(), vector.size()), which is counter-intuitive in my opinion. > > String(UChar*, size_t) already returns the empty string when size ==0: > > // Construct a string with UTF-16 data. > String::String(const UChar* characters, unsigned length) > : m_impl(characters ? StringImpl::create(characters, length) : 0) > { > } > > So this change makes the behavior consistent. Not when the length is zero, when characters is zero! 832812 7 eric 2013-02-14 01:07:55 -0800 (In reply to comment #6) > > > It will also mean String(vector) != String(vector.data(), vector.size()), which is counter-intuitive in my opinion. > > > > String(UChar*, size_t) already returns the empty string when size ==0: > > > > // Construct a string with UTF-16 data. > > String::String(const UChar* characters, unsigned length) > > : m_impl(characters ? StringImpl::create(characters, length) : 0) > > { > > } > > > > So this change makes the behavior consistent. > > Not when the length is zero, when characters is zero! Correct. That only returns *null* when characters are zero, but returns *empty* when length is zero. :) That's what I"m changing String(Vector) to do. :) Before this patch, they're inconsistent. STring(Vector) in TOT will return a null string when the vector has size 0. 832814 8 eric 2013-02-14 01:09:36 -0800 Vector can never produce a null .data(), so String(vector.data(), vector.size()) can never return a null string. Just like what I'm changing String(Vector) to do with this patch. 832815 9 benjamin 2013-02-14 01:10:37 -0800 (In reply to comment #8) > Vector can never produce a null .data(), so String(vector.data(), vector.size()) can never return a null string. Just like what I'm changing String(Vector) to do with this patch. Oh, really, I got that wrong about vector. I thought data() of an empty vector was 0. 832820 10 eric 2013-02-14 01:13:39 -0800 (In reply to comment #9) > (In reply to comment #8) > > Vector can never produce a null .data(), so String(vector.data(), vector.size()) can never return a null string. Just like what I'm changing String(Vector) to do with this patch. > > Oh, really, I got that wrong about vector. > I thought data() of an empty vector was 0. Hmm.. You may be right. Looking at VectorBufferBase, it appears m_buffer can be null. Maybe I'm barking up the wrong tree. Will look again in the morning. 832822 11 eric 2013-02-14 01:16:12 -0800 It's possible that Vectors with inline capacity can never have a data() which is null. If so, that may be a "bug" in vector, that data() is non-null for inline vectors. Or at least that would explain this behavior difference. 832823 12 benjamin 2013-02-14 01:17:38 -0800 > Hmm.. You may be right. > > Looking at VectorBufferBase, it appears m_buffer can be null. > > Maybe I'm barking up the wrong tree. Will look again in the morning. Skimming over Vector: your data non-zero because its inline capacity is non zero. This is messed up, I don't have an easy answer here for the Vector->String conversion :( 832826 13 eric 2013-02-14 01:18:20 -0800 Yeah. It appears that Vectors of size 0 with an inline capacity will never have a null data(), but Vectors without inline capacity and size 0 will. To fix this, we should just key off of vector.data() instead, and then the behavior will match String(UChar*, size_t) exactly. :) 832829 14 eric 2013-02-14 01:23:09 -0800 I've filed bug 109792 to track the Vector oddity. I'll post an updated patch now. 832830 15 benjamin 2013-02-14 01:28:51 -0800 Pretty funny we could be arguing while being both right. Silly Vector :) 832832 16 188282 eric 2013-02-14 01:31:17 -0800 Created attachment 188282 Patch 832837 17 eric 2013-02-14 01:33:19 -0800 We were just emphatically agreeing with one another. :) 832839 18 188282 benjamin 2013-02-14 01:33:32 -0800 Comment on attachment 188282 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=188282&action=review > Source/WTF/ChangeLog:20 > + between threads). The main-thread parser path uses AtomicHTMLToken which Two spaces after the period. 832848 19 188288 eric 2013-02-14 01:38:54 -0800 Created attachment 188288 Patch for landing 832859 20 benjamin 2013-02-14 01:47:26 -0800 To come back to the problem in general: Usually, I am strongly against reading the pointer of an array/vector if the passed length is 0. For String, it just works well in practice that creating a String without a buffer (characters = 0) means there are no characters->null strings. The problem is this behavior should be kept consistent with String(pointer, length), and we end up with oddities like checking the pointer before the length. I start to think it may be a better choice to have String(char*) and String(char*, size_t) return empty strings. It would become the job of the caller to create null strings if necessary. A recent discussion with Darin also put the idea in my head that the implicit creation of null String can lead to unfortunate side effects. I tend to like null string because they are really really cheap to pass around code path. But problems like this patch make me think we may be abusing them in WebKit. 832887 21 188288 webkit.review.bot 2013-02-14 02:24:56 -0800 Comment on attachment 188288 Patch for landing Clearing flags on attachment: 188288 Committed r142863: <http://trac.webkit.org/changeset/142863> 832888 22 webkit.review.bot 2013-02-14 02:25:01 -0800 All reviewed patches have been landed. Closing bug. 833166 23 eric 2013-02-14 09:47:34 -0800 (In reply to comment #20) > To come back to the problem in general: > > Usually, I am strongly against reading the pointer of an array/vector if the passed length is 0. > > For String, it just works well in practice that creating a String without a buffer (characters = 0) means there are no characters->null strings. > The problem is this behavior should be kept consistent with String(pointer, length), and we end up with oddities like checking the pointer before the length. > > I start to think it may be a better choice to have String(char*) and String(char*, size_t) return empty strings. It would become the job of the caller to create null strings if necessary. A recent discussion with Darin also put the idea in my head that the implicit creation of null String can lead to unfortunate side effects. That seems totally reasonable to me. > I tend to like null string because they are really really cheap to pass around code path. But problems like this patch make me think we may be abusing them in WebKit. Agreed. 833168 24 darin 2013-02-14 09:48:50 -0800 I don’t think this is the best fix. I suggest we always create empty strings, not null strings, in this constructor. 833172 25 darin 2013-02-14 09:50:21 -0800 We should still check size, not data, but we should construct an empty string, not a null string, in that case. It’s a bad idea to behave differently based on what the data pointer returns for an empty vector. That leads to the confusing FIXME in the header and it’s not what we want for these classes. 833184 26 darin 2013-02-14 09:58:00 -0800 We can continue to discuss whether to remove the "create a null string if passed a null pointer" behavior of the pointer-based versions of these functions. But for the vector version, we should never create a null string since there is no such thing as a null vector. The patch we landed accidentally invents the concept of a null vector because if the the vector's data is 0 it creates a null string. We don’t want that for vectors. I understand that the old code glued together vectors and strings in the obvious way, and therefore it also had that strange behavior of inventing the concept of a null vector. And I agree with Ben that one way to fix that is to remove the String constructor function concept of making a null string if passed a null character pointer. But we can and should fix the vector part of this now while we continue that discussion. 833189 27 eric 2013-02-14 10:00:00 -0800 It sounds like Darin is advocating for the first patch on this bug, which checked size and returned empty(). What we landed matches previous String(UChar*, size_t) behavior, but I agree, is confusing. I'm totally happy to see both String(Vector) and STring(UChar*, size_t) move to returning empty() in the length=0 case and never null. 833191 28 eric 2013-02-14 10:02:03 -0800 I'll post a patch to fix String(Vector) to always return empty on size=0 shortly. 833193 29 darin 2013-02-14 10:05:20 -0800 (In reply to comment #27) > It sounds like Darin is advocating for the first patch on this bug, which checked size and returned empty(). Yes. > What we landed matches previous String(UChar*, size_t) behavior, but I agree, is confusing. It matches String(UChar*, size_t) behavior iff you are also assuming you’d pass vector’s data and size through directly. But the point is that we want to correctly convert an empty vector, and that requires more than just fetching the data and size and passing them through. In my mind this is a separate issue from the design of String(const UChar*, size_t). > I'm totally happy to see both String(Vector) and String(UChar*, size_t) move to returning empty() in the length=0 case and never null. I am certain we should correct String(Vector) so it correctly makes an empty string from an empty vector, even if the call sites inside the tokenizer just passed through the data and size before. There’s a higher standard for a shared WTF function than for local code in one part of WebKit. I am not sure that removing the “you can get a null string by passing a null pointer” behavior from String(UChar*, size_t) is the right thing to do and we should reflect on that more before making a change. One tiny factor is that, as Ben points out, constructing an empty string is more costly than constructing a null string. And given the inlining, there’s even a bit of code bloat factor. 833209 30 eric 2013-02-14 10:26:11 -0800 Reopening to attach new patch. 833210 31 188378 eric 2013-02-14 10:26:13 -0800 Created attachment 188378 Back to the original fix, now with more context 833217 32 188378 darin 2013-02-14 10:38:15 -0800 Comment on attachment 188378 Back to the original fix, now with more context View in context: https://bugs.webkit.org/attachment.cgi?id=188378&action=review > Source/WTF/wtf/text/WTFString.h:118 > + // NOTE: This is different from String(vector.data(), vector.size()) > + // which will sometimes return a null string when vector.data() is null > + // which can only occur for vectors without inline capacity. > + // See: https://bugs.webkit.org/show_bug.cgi?id=109792 I personally would not include this note, but I’m OK leaving it in. 833261 33 188378 webkit.review.bot 2013-02-14 11:18:52 -0800 Comment on attachment 188378 Back to the original fix, now with more context Clearing flags on attachment: 188378 Committed r142894: <http://trac.webkit.org/changeset/142894> 833262 34 webkit.review.bot 2013-02-14 11:18:58 -0800 All reviewed patches have been landed. Closing bug. 833299 35 benjamin 2013-02-14 12:03:33 -0800 (In reply to comment #32) > (From update of attachment 188378 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=188378&action=review > > > Source/WTF/wtf/text/WTFString.h:118 > > + // NOTE: This is different from String(vector.data(), vector.size()) > > + // which will sometimes return a null string when vector.data() is null > > + // which can only occur for vectors without inline capacity. > > + // See: https://bugs.webkit.org/show_bug.cgi?id=109792 > > I personally would not include this note, but I’m OK leaving it in. This is the reason why I wanted to change everything at once. I would prefer to have completely consistent behavior, no exception in one direction or an other. 188263 2013-02-13 22:23:22 -0800 2013-02-14 01:31:14 -0800 Patch bug-109784-20130213221953.patch text/plain 9752 eric U3VidmVyc2lvbiBSZXZpc2lvbjogMTQyODQ5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGRmMjQxMDcxZTc4NjJiNzhmMTUxMDRj M2JjZWJlYWYxNGQ0ODVhMzEuLmE4YjIwNTRjNDNiOGQzM2I3YWIzMzFlMWE1MzFhM2UyNTZmOTk1 NzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMTMtMDItMTMgIEVyaWMgU2VpZGVsICA8ZXJpY0B3 ZWJraXQub3JnPgorCisgICAgICAgIFJFR1JFU1NJT04ocjE0MjcxMik6IGF0dHJpYnV0ZSB2YWx1 ZXMgc2hvdyB1cCBhcyAiKG51bGwpIiBpbnN0ZWFkIG9mIG51bGwgd2l0aCB0aGUgdGhyZWFkZWQg cGFyc2VyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MDk3ODQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBX aGVuIEkgY2hhbmdlZCBtYW55IGNhbGxzaXRlcyB0byB1c2UgdGhlIChleGlzdGluZykgU3RyaW5n KFZlY3RvcikgY29uc3RydWN0b3IKKyAgICAgICAgSSBpbmFkdmVydGFudGx5IG1hZGUgdGhvc2Ug Y2FsbHNpdGVzIGNvbnZlcnQgZW1wdHkgdmVjdG9ycyB0byBudWxsIHN0cmluZ3MKKyAgICAgICAg aW5zdGVhZCBvZiBlbXB0eSBzdHJpbmdzIChsaWtlIFN0cmluZyhVQ2hhcixzaXplX3QpIGRvZXMp LgorCisgICAgICAgIEkgYmVsaWV2ZSB0aGlzIGlzIGFuIGVycm9yIGluIHRoZSBTdHJpbmcoVmVj dG9yKSBjb25zdHJ1Y3RvciBhbmQgc28gSSBoYXZlCisgICAgICAgIGNvcnJlY3RlZCBpdCAoYW5k IGRvY3VtZW50ZWQgdGhlIGJlaGF2aW9yKS4KKworICAgICAgICBUaGlzIGlzIGVhc2lseSBkZXRl Y3RhYmxlIHdpdGggdGhlIHRocmVhZGVkIHBhcnNlciwgYmVjYXVzZSB3ZSB1c2UgU3RyaW5nCisg ICAgICAgIGluc3RlYWQgb2YgQXRvbWljU3RyaW5nIGluIG91ciBDb21wYWN0VG9rZW4gKHVzZWQg dG8gc2VuZCB0aGUgVG9rZW4gZGF0YQorICAgICAgICBiZXR3ZWVuIHRocmVhZHMpLiAgVGhlIG1h aW4tdGhyZWFkIHBhcnNlciBwYXRoIHVzZXMgQXRvbWljSFRNTFRva2VuIHdoaWNoCisgICAgICAg IHVzZXMgQXRvbWljU3RyaW5nKFZlY3RvcikgYW5kIGRvZXMgbm90IGhhdmUgdGhpcyBidWcuCisK KyAgICAgICAgKiB3dGYvdGV4dC9XVEZTdHJpbmcuaDoKKyAgICAgICAgKFN0cmluZyk6CisgICAg ICAgIChXVEY6OlN0cmluZzo6U3RyaW5nKToKKwogMjAxMy0wMi0xMyAgWmFuIERvYmVyc2VrICA8 emRvYmVyc2VrQGlnYWxpYS5jb20+CiAKICAgICAgICAgVGhlICdnbG9iYWwgaXNpbmYvaXNuYW4n IGNvbXBpbGVyIHF1aXJrIHJlcXVpcmVkIHdoZW4gdXNpbmcgY2xhbmcgd2l0aCBsaWJzdGRjKysK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL3RleHQvV1RGU3RyaW5nLmggYi9Tb3VyY2UvV1RG L3d0Zi90ZXh0L1dURlN0cmluZy5oCmluZGV4IDBiODc2OWQ5ODBmZGQ3NTMwNDdiMWUxY2FiNWQz ZGVkMTIzMmMwNTguLmU2YTcyYTdhNDhmYTFiM2ViNDBhNzU4ZGQ2ZThmNzAxODY4MGJlOGMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL3RleHQvV1RGU3RyaW5nLmgKKysrIGIvU291cmNlL1dU Ri93dGYvdGV4dC9XVEZTdHJpbmcuaApAQCAtMTEwLDYgKzExMCw3IEBAIHB1YmxpYzoKIAogICAg IC8vIENvbnN0cnVjdCBhIHN0cmluZyBieSBjb3B5aW5nIHRoZSBjb250ZW50cyBvZiBhIHZlY3Rv ci4gIFRvIGF2b2lkCiAgICAgLy8gY29weWluZywgY29uc2lkZXIgdXNpbmcgU3RyaW5nOjphZG9w dCBpbnN0ZWFkLgorICAgIC8vIElmIHRoZSBWZWN0b3IgaXMgc2l6ZSA9PSAwLCB0aGlzIHdpbGwg cHJvZHVjZSBhbiBlbXB0eSBzdHJpbmcuCiAgICAgdGVtcGxhdGU8c2l6ZV90IGlubGluZUNhcGFj aXR5PgogICAgIGV4cGxpY2l0IFN0cmluZyhjb25zdCBWZWN0b3I8VUNoYXIsIGlubGluZUNhcGFj aXR5PiYpOwogCkBAIC01MzUsNyArNTM2LDcgQEAgaW5saW5lIHZvaWQgc3dhcChTdHJpbmcmIGEs IFN0cmluZyYgYikgeyBhLnN3YXAoYik7IH0KIAogdGVtcGxhdGU8c2l6ZV90IGlubGluZUNhcGFj aXR5PgogU3RyaW5nOjpTdHJpbmcoY29uc3QgVmVjdG9yPFVDaGFyLCBpbmxpbmVDYXBhY2l0eT4m IHZlY3RvcikKLSAgICA6IG1faW1wbCh2ZWN0b3Iuc2l6ZSgpID8gU3RyaW5nSW1wbDo6Y3JlYXRl KHZlY3Rvci5kYXRhKCksIHZlY3Rvci5zaXplKCkpIDogMCkKKyAgICA6IG1faW1wbCh2ZWN0b3Iu c2l6ZSgpID8gU3RyaW5nSW1wbDo6Y3JlYXRlKHZlY3Rvci5kYXRhKCksIHZlY3Rvci5zaXplKCkp IDogU3RyaW5nSW1wbDo6ZW1wdHkoKSkKIHsKIH0KIApkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJl bmRlclRyZWUvRHVtcFJlbmRlclRyZWUudmN4cHJvai9EdW1wUmVuZGVyVHJlZS5zbG4gYi9Ub29s cy9EdW1wUmVuZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS52Y3hwcm9qL0R1bXBSZW5kZXJUcmVlLnNs bgppbmRleCBlMGFkMjQxMDk0MjgyYTJiYjJhYWM1NDhmMzE0MGVhMTgzYjhkZmQ0Li4yODVlMjUy NTkwNmFjNTY3NjViMzUzZGI2NmZhMjNlYTZmZTQ5NThhIDEwMDY0NAotLS0gYS9Ub29scy9EdW1w UmVuZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS52Y3hwcm9qL0R1bXBSZW5kZXJUcmVlLnNsbgorKysg Yi9Ub29scy9EdW1wUmVuZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS52Y3hwcm9qL0R1bXBSZW5kZXJU cmVlLnNsbgpAQCAtMSw1NiArMSw1NiBAQAot77u/DQotTWljcm9zb2Z0IFZpc3VhbCBTdHVkaW8g U29sdXRpb24gRmlsZSwgRm9ybWF0IFZlcnNpb24gMTEuMDANCi0jIFZpc3VhbCBTdHVkaW8gMjAx MA0KLVByb2plY3QoIns4QkM5Q0VCOC04QjRBLTExRDAtOEQxMS0wMEEwQzkxQkM5NDJ9IikgPSAi VGVzdE5ldHNjYXBlUGx1Z2luIiwgIlRlc3ROZXRzY2FwZVBsdWdpblxUZXN0TmV0c2NhcGVQbHVn aW4udmN4cHJvaiIsICJ7QzA3MzczOTgtMzU2NS00MzlFLUEyQjgtQUIyQkU0RDU0MzBDfSINCi1F bmRQcm9qZWN0DQotUHJvamVjdCgiezhCQzlDRUI4LThCNEEtMTFEMC04RDExLTAwQTBDOTFCQzk0 Mn0iKSA9ICJJbWFnZURpZmZMYXVuY2hlciIsICJJbWFnZURpZmZcSW1hZ2VEaWZmTGF1bmNoZXIu dmN4cHJvaiIsICJ7REQ3OTQ5QjYtRjJCNC00N0MyLTlDNDItRTIxRTg0Q0IxMDE3fSINCi0JUHJv amVjdFNlY3Rpb24oUHJvamVjdERlcGVuZGVuY2llcykgPSBwb3N0UHJvamVjdA0KLQkJezU5Q0Mw NTQ3LTcwQUMtNDk5Qy05QjE5LUVDMDFDNkY2MTEzN30gPSB7NTlDQzA1NDctNzBBQy00OTlDLTlC MTktRUMwMUM2RjYxMTM3fQ0KLQlFbmRQcm9qZWN0U2VjdGlvbg0KLUVuZFByb2plY3QNCi1Qcm9q ZWN0KCJ7OEJDOUNFQjgtOEI0QS0xMUQwLThEMTEtMDBBMEM5MUJDOTQyfSIpID0gIkltYWdlRGlm ZiIsICJJbWFnZURpZmZcSW1hZ2VEaWZmLnZjeHByb2oiLCAiezU5Q0MwNTQ3LTcwQUMtNDk5Qy05 QjE5LUVDMDFDNkY2MTEzN30iDQotCVByb2plY3RTZWN0aW9uKFByb2plY3REZXBlbmRlbmNpZXMp ID0gcG9zdFByb2plY3QNCi0JCXtDMDczNzM5OC0zNTY1LTQzOUUtQTJCOC1BQjJCRTRENTQzMEN9 ID0ge0MwNzM3Mzk4LTM1NjUtNDM5RS1BMkI4LUFCMkJFNEQ1NDMwQ30NCi0JRW5kUHJvamVjdFNl Y3Rpb24NCi1FbmRQcm9qZWN0DQotUHJvamVjdCgiezhCQzlDRUI4LThCNEEtMTFEMC04RDExLTAw QTBDOTFCQzk0Mn0iKSA9ICJEdW1wUmVuZGVyVHJlZSIsICJEdW1wUmVuZGVyVHJlZVxEdW1wUmVu ZGVyVHJlZS52Y3hwcm9qIiwgIns2NTY3REZENC1ENkRFLTRDRDUtODI1RC0xN0UzNTNEMTYwRTF9 Ig0KLQlQcm9qZWN0U2VjdGlvbihQcm9qZWN0RGVwZW5kZW5jaWVzKSA9IHBvc3RQcm9qZWN0DQot CQl7REQ3OTQ5QjYtRjJCNC00N0MyLTlDNDItRTIxRTg0Q0IxMDE3fSA9IHtERDc5NDlCNi1GMkI0 LTQ3QzItOUM0Mi1FMjFFODRDQjEwMTd9DQotCUVuZFByb2plY3RTZWN0aW9uDQotRW5kUHJvamVj dA0KLVByb2plY3QoIns4QkM5Q0VCOC04QjRBLTExRDAtOEQxMS0wMEEwQzkxQkM5NDJ9IikgPSAi RHVtcFJlbmRlclRyZWVMYXVuY2hlciIsICJEdW1wUmVuZGVyVHJlZVxEdW1wUmVuZGVyVHJlZUxh dW5jaGVyLnZjeHByb2oiLCAiezI5NzRFQTAyLTg0MEItNDk5NS04NzE5LTg5MjBBNjEwMDZGMX0i DQotCVByb2plY3RTZWN0aW9uKFByb2plY3REZXBlbmRlbmNpZXMpID0gcG9zdFByb2plY3QNCi0J CXs2NTY3REZENC1ENkRFLTRDRDUtODI1RC0xN0UzNTNEMTYwRTF9ID0gezY1NjdERkQ0LUQ2REUt NENENS04MjVELTE3RTM1M0QxNjBFMX0NCi0JRW5kUHJvamVjdFNlY3Rpb24NCi1FbmRQcm9qZWN0 DQotR2xvYmFsDQotCUdsb2JhbFNlY3Rpb24oU29sdXRpb25Db25maWd1cmF0aW9uUGxhdGZvcm1z KSA9IHByZVNvbHV0aW9uDQotCQlEZWJ1Z3xXaW4zMiA9IERlYnVnfFdpbjMyDQotCQlSZWxlYXNl fFdpbjMyID0gUmVsZWFzZXxXaW4zMg0KLQlFbmRHbG9iYWxTZWN0aW9uDQotCUdsb2JhbFNlY3Rp b24oUHJvamVjdENvbmZpZ3VyYXRpb25QbGF0Zm9ybXMpID0gcG9zdFNvbHV0aW9uDQotCQl7QzA3 MzczOTgtMzU2NS00MzlFLUEyQjgtQUIyQkU0RDU0MzBDfS5EZWJ1Z3xXaW4zMi5BY3RpdmVDZmcg PSBEZWJ1Z3xXaW4zMg0KLQkJe0MwNzM3Mzk4LTM1NjUtNDM5RS1BMkI4LUFCMkJFNEQ1NDMwQ30u RGVidWd8V2luMzIuQnVpbGQuMCA9IERlYnVnfFdpbjMyDQotCQl7QzA3MzczOTgtMzU2NS00MzlF LUEyQjgtQUIyQkU0RDU0MzBDfS5SZWxlYXNlfFdpbjMyLkFjdGl2ZUNmZyA9IFJlbGVhc2V8V2lu MzINCi0JCXtDMDczNzM5OC0zNTY1LTQzOUUtQTJCOC1BQjJCRTRENTQzMEN9LlJlbGVhc2V8V2lu MzIuQnVpbGQuMCA9IFJlbGVhc2V8V2luMzINCi0JCXtERDc5NDlCNi1GMkI0LTQ3QzItOUM0Mi1F MjFFODRDQjEwMTd9LkRlYnVnfFdpbjMyLkFjdGl2ZUNmZyA9IERlYnVnfFdpbjMyDQotCQl7REQ3 OTQ5QjYtRjJCNC00N0MyLTlDNDItRTIxRTg0Q0IxMDE3fS5EZWJ1Z3xXaW4zMi5CdWlsZC4wID0g RGVidWd8V2luMzINCi0JCXtERDc5NDlCNi1GMkI0LTQ3QzItOUM0Mi1FMjFFODRDQjEwMTd9LlJl bGVhc2V8V2luMzIuQWN0aXZlQ2ZnID0gUmVsZWFzZXxXaW4zMg0KLQkJe0RENzk0OUI2LUYyQjQt NDdDMi05QzQyLUUyMUU4NENCMTAxN30uUmVsZWFzZXxXaW4zMi5CdWlsZC4wID0gUmVsZWFzZXxX aW4zMg0KLQkJezU5Q0MwNTQ3LTcwQUMtNDk5Qy05QjE5LUVDMDFDNkY2MTEzN30uRGVidWd8V2lu MzIuQWN0aXZlQ2ZnID0gRGVidWd8V2luMzINCi0JCXs1OUNDMDU0Ny03MEFDLTQ5OUMtOUIxOS1F QzAxQzZGNjExMzd9LkRlYnVnfFdpbjMyLkJ1aWxkLjAgPSBEZWJ1Z3xXaW4zMg0KLQkJezU5Q0Mw NTQ3LTcwQUMtNDk5Qy05QjE5LUVDMDFDNkY2MTEzN30uUmVsZWFzZXxXaW4zMi5BY3RpdmVDZmcg PSBSZWxlYXNlfFdpbjMyDQotCQl7NTlDQzA1NDctNzBBQy00OTlDLTlCMTktRUMwMUM2RjYxMTM3 fS5SZWxlYXNlfFdpbjMyLkJ1aWxkLjAgPSBSZWxlYXNlfFdpbjMyDQotCQl7NjU2N0RGRDQtRDZE RS00Q0Q1LTgyNUQtMTdFMzUzRDE2MEUxfS5EZWJ1Z3xXaW4zMi5BY3RpdmVDZmcgPSBEZWJ1Z3xX aW4zMg0KLQkJezY1NjdERkQ0LUQ2REUtNENENS04MjVELTE3RTM1M0QxNjBFMX0uRGVidWd8V2lu MzIuQnVpbGQuMCA9IERlYnVnfFdpbjMyDQotCQl7NjU2N0RGRDQtRDZERS00Q0Q1LTgyNUQtMTdF MzUzRDE2MEUxfS5SZWxlYXNlfFdpbjMyLkFjdGl2ZUNmZyA9IFJlbGVhc2V8V2luMzINCi0JCXs2 NTY3REZENC1ENkRFLTRDRDUtODI1RC0xN0UzNTNEMTYwRTF9LlJlbGVhc2V8V2luMzIuQnVpbGQu MCA9IFJlbGVhc2V8V2luMzINCi0JCXsyOTc0RUEwMi04NDBCLTQ5OTUtODcxOS04OTIwQTYxMDA2 RjF9LkRlYnVnfFdpbjMyLkFjdGl2ZUNmZyA9IERlYnVnfFdpbjMyDQotCQl7Mjk3NEVBMDItODQw Qi00OTk1LTg3MTktODkyMEE2MTAwNkYxfS5EZWJ1Z3xXaW4zMi5CdWlsZC4wID0gRGVidWd8V2lu MzINCi0JCXsyOTc0RUEwMi04NDBCLTQ5OTUtODcxOS04OTIwQTYxMDA2RjF9LlJlbGVhc2V8V2lu MzIuQWN0aXZlQ2ZnID0gUmVsZWFzZXxXaW4zMg0KLQkJezI5NzRFQTAyLTg0MEItNDk5NS04NzE5 LTg5MjBBNjEwMDZGMX0uUmVsZWFzZXxXaW4zMi5CdWlsZC4wID0gUmVsZWFzZXxXaW4zMg0KLQlF bmRHbG9iYWxTZWN0aW9uDQotCUdsb2JhbFNlY3Rpb24oU29sdXRpb25Qcm9wZXJ0aWVzKSA9IHBy ZVNvbHV0aW9uDQotCQlIaWRlU29sdXRpb25Ob2RlID0gRkFMU0UNCi0JRW5kR2xvYmFsU2VjdGlv bg0KLUVuZEdsb2JhbA0KK++7vworTWljcm9zb2Z0IFZpc3VhbCBTdHVkaW8gU29sdXRpb24gRmls ZSwgRm9ybWF0IFZlcnNpb24gMTEuMDAKKyMgVmlzdWFsIFN0dWRpbyAyMDEwCitQcm9qZWN0KCJ7 OEJDOUNFQjgtOEI0QS0xMUQwLThEMTEtMDBBMEM5MUJDOTQyfSIpID0gIlRlc3ROZXRzY2FwZVBs dWdpbiIsICJUZXN0TmV0c2NhcGVQbHVnaW5cVGVzdE5ldHNjYXBlUGx1Z2luLnZjeHByb2oiLCAi e0MwNzM3Mzk4LTM1NjUtNDM5RS1BMkI4LUFCMkJFNEQ1NDMwQ30iCitFbmRQcm9qZWN0CitQcm9q ZWN0KCJ7OEJDOUNFQjgtOEI0QS0xMUQwLThEMTEtMDBBMEM5MUJDOTQyfSIpID0gIkltYWdlRGlm ZkxhdW5jaGVyIiwgIkltYWdlRGlmZlxJbWFnZURpZmZMYXVuY2hlci52Y3hwcm9qIiwgIntERDc5 NDlCNi1GMkI0LTQ3QzItOUM0Mi1FMjFFODRDQjEwMTd9IgorCVByb2plY3RTZWN0aW9uKFByb2pl Y3REZXBlbmRlbmNpZXMpID0gcG9zdFByb2plY3QKKwkJezU5Q0MwNTQ3LTcwQUMtNDk5Qy05QjE5 LUVDMDFDNkY2MTEzN30gPSB7NTlDQzA1NDctNzBBQy00OTlDLTlCMTktRUMwMUM2RjYxMTM3fQor CUVuZFByb2plY3RTZWN0aW9uCitFbmRQcm9qZWN0CitQcm9qZWN0KCJ7OEJDOUNFQjgtOEI0QS0x MUQwLThEMTEtMDBBMEM5MUJDOTQyfSIpID0gIkltYWdlRGlmZiIsICJJbWFnZURpZmZcSW1hZ2VE aWZmLnZjeHByb2oiLCAiezU5Q0MwNTQ3LTcwQUMtNDk5Qy05QjE5LUVDMDFDNkY2MTEzN30iCisJ UHJvamVjdFNlY3Rpb24oUHJvamVjdERlcGVuZGVuY2llcykgPSBwb3N0UHJvamVjdAorCQl7QzA3 MzczOTgtMzU2NS00MzlFLUEyQjgtQUIyQkU0RDU0MzBDfSA9IHtDMDczNzM5OC0zNTY1LTQzOUUt QTJCOC1BQjJCRTRENTQzMEN9CisJRW5kUHJvamVjdFNlY3Rpb24KK0VuZFByb2plY3QKK1Byb2pl Y3QoIns4QkM5Q0VCOC04QjRBLTExRDAtOEQxMS0wMEEwQzkxQkM5NDJ9IikgPSAiRHVtcFJlbmRl clRyZWUiLCAiRHVtcFJlbmRlclRyZWVcRHVtcFJlbmRlclRyZWUudmN4cHJvaiIsICJ7NjU2N0RG RDQtRDZERS00Q0Q1LTgyNUQtMTdFMzUzRDE2MEUxfSIKKwlQcm9qZWN0U2VjdGlvbihQcm9qZWN0 RGVwZW5kZW5jaWVzKSA9IHBvc3RQcm9qZWN0CisJCXtERDc5NDlCNi1GMkI0LTQ3QzItOUM0Mi1F MjFFODRDQjEwMTd9ID0ge0RENzk0OUI2LUYyQjQtNDdDMi05QzQyLUUyMUU4NENCMTAxN30KKwlF bmRQcm9qZWN0U2VjdGlvbgorRW5kUHJvamVjdAorUHJvamVjdCgiezhCQzlDRUI4LThCNEEtMTFE MC04RDExLTAwQTBDOTFCQzk0Mn0iKSA9ICJEdW1wUmVuZGVyVHJlZUxhdW5jaGVyIiwgIkR1bXBS ZW5kZXJUcmVlXER1bXBSZW5kZXJUcmVlTGF1bmNoZXIudmN4cHJvaiIsICJ7Mjk3NEVBMDItODQw Qi00OTk1LTg3MTktODkyMEE2MTAwNkYxfSIKKwlQcm9qZWN0U2VjdGlvbihQcm9qZWN0RGVwZW5k ZW5jaWVzKSA9IHBvc3RQcm9qZWN0CisJCXs2NTY3REZENC1ENkRFLTRDRDUtODI1RC0xN0UzNTNE MTYwRTF9ID0gezY1NjdERkQ0LUQ2REUtNENENS04MjVELTE3RTM1M0QxNjBFMX0KKwlFbmRQcm9q ZWN0U2VjdGlvbgorRW5kUHJvamVjdAorR2xvYmFsCisJR2xvYmFsU2VjdGlvbihTb2x1dGlvbkNv bmZpZ3VyYXRpb25QbGF0Zm9ybXMpID0gcHJlU29sdXRpb24KKwkJRGVidWd8V2luMzIgPSBEZWJ1 Z3xXaW4zMgorCQlSZWxlYXNlfFdpbjMyID0gUmVsZWFzZXxXaW4zMgorCUVuZEdsb2JhbFNlY3Rp b24KKwlHbG9iYWxTZWN0aW9uKFByb2plY3RDb25maWd1cmF0aW9uUGxhdGZvcm1zKSA9IHBvc3RT b2x1dGlvbgorCQl7QzA3MzczOTgtMzU2NS00MzlFLUEyQjgtQUIyQkU0RDU0MzBDfS5EZWJ1Z3xX aW4zMi5BY3RpdmVDZmcgPSBEZWJ1Z3xXaW4zMgorCQl7QzA3MzczOTgtMzU2NS00MzlFLUEyQjgt QUIyQkU0RDU0MzBDfS5EZWJ1Z3xXaW4zMi5CdWlsZC4wID0gRGVidWd8V2luMzIKKwkJe0MwNzM3 Mzk4LTM1NjUtNDM5RS1BMkI4LUFCMkJFNEQ1NDMwQ30uUmVsZWFzZXxXaW4zMi5BY3RpdmVDZmcg PSBSZWxlYXNlfFdpbjMyCisJCXtDMDczNzM5OC0zNTY1LTQzOUUtQTJCOC1BQjJCRTRENTQzMEN9 LlJlbGVhc2V8V2luMzIuQnVpbGQuMCA9IFJlbGVhc2V8V2luMzIKKwkJe0RENzk0OUI2LUYyQjQt NDdDMi05QzQyLUUyMUU4NENCMTAxN30uRGVidWd8V2luMzIuQWN0aXZlQ2ZnID0gRGVidWd8V2lu MzIKKwkJe0RENzk0OUI2LUYyQjQtNDdDMi05QzQyLUUyMUU4NENCMTAxN30uRGVidWd8V2luMzIu QnVpbGQuMCA9IERlYnVnfFdpbjMyCisJCXtERDc5NDlCNi1GMkI0LTQ3QzItOUM0Mi1FMjFFODRD QjEwMTd9LlJlbGVhc2V8V2luMzIuQWN0aXZlQ2ZnID0gUmVsZWFzZXxXaW4zMgorCQl7REQ3OTQ5 QjYtRjJCNC00N0MyLTlDNDItRTIxRTg0Q0IxMDE3fS5SZWxlYXNlfFdpbjMyLkJ1aWxkLjAgPSBS ZWxlYXNlfFdpbjMyCisJCXs1OUNDMDU0Ny03MEFDLTQ5OUMtOUIxOS1FQzAxQzZGNjExMzd9LkRl YnVnfFdpbjMyLkFjdGl2ZUNmZyA9IERlYnVnfFdpbjMyCisJCXs1OUNDMDU0Ny03MEFDLTQ5OUMt OUIxOS1FQzAxQzZGNjExMzd9LkRlYnVnfFdpbjMyLkJ1aWxkLjAgPSBEZWJ1Z3xXaW4zMgorCQl7 NTlDQzA1NDctNzBBQy00OTlDLTlCMTktRUMwMUM2RjYxMTM3fS5SZWxlYXNlfFdpbjMyLkFjdGl2 ZUNmZyA9IFJlbGVhc2V8V2luMzIKKwkJezU5Q0MwNTQ3LTcwQUMtNDk5Qy05QjE5LUVDMDFDNkY2 MTEzN30uUmVsZWFzZXxXaW4zMi5CdWlsZC4wID0gUmVsZWFzZXxXaW4zMgorCQl7NjU2N0RGRDQt RDZERS00Q0Q1LTgyNUQtMTdFMzUzRDE2MEUxfS5EZWJ1Z3xXaW4zMi5BY3RpdmVDZmcgPSBEZWJ1 Z3xXaW4zMgorCQl7NjU2N0RGRDQtRDZERS00Q0Q1LTgyNUQtMTdFMzUzRDE2MEUxfS5EZWJ1Z3xX aW4zMi5CdWlsZC4wID0gRGVidWd8V2luMzIKKwkJezY1NjdERkQ0LUQ2REUtNENENS04MjVELTE3 RTM1M0QxNjBFMX0uUmVsZWFzZXxXaW4zMi5BY3RpdmVDZmcgPSBSZWxlYXNlfFdpbjMyCisJCXs2 NTY3REZENC1ENkRFLTRDRDUtODI1RC0xN0UzNTNEMTYwRTF9LlJlbGVhc2V8V2luMzIuQnVpbGQu MCA9IFJlbGVhc2V8V2luMzIKKwkJezI5NzRFQTAyLTg0MEItNDk5NS04NzE5LTg5MjBBNjEwMDZG MX0uRGVidWd8V2luMzIuQWN0aXZlQ2ZnID0gRGVidWd8V2luMzIKKwkJezI5NzRFQTAyLTg0MEIt NDk5NS04NzE5LTg5MjBBNjEwMDZGMX0uRGVidWd8V2luMzIuQnVpbGQuMCA9IERlYnVnfFdpbjMy CisJCXsyOTc0RUEwMi04NDBCLTQ5OTUtODcxOS04OTIwQTYxMDA2RjF9LlJlbGVhc2V8V2luMzIu QWN0aXZlQ2ZnID0gUmVsZWFzZXxXaW4zMgorCQl7Mjk3NEVBMDItODQwQi00OTk1LTg3MTktODky MEE2MTAwNkYxfS5SZWxlYXNlfFdpbjMyLkJ1aWxkLjAgPSBSZWxlYXNlfFdpbjMyCisJRW5kR2xv YmFsU2VjdGlvbgorCUdsb2JhbFNlY3Rpb24oU29sdXRpb25Qcm9wZXJ0aWVzKSA9IHByZVNvbHV0 aW9uCisJCUhpZGVTb2x1dGlvbk5vZGUgPSBGQUxTRQorCUVuZEdsb2JhbFNlY3Rpb24KK0VuZEds b2JhbAo= 188282 2013-02-14 01:31:17 -0800 2013-02-14 01:38:51 -0800 Patch bug-109784-20130214012745.patch text/plain 2744 eric U3VidmVyc2lvbiBSZXZpc2lvbjogMTQyODU5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGRmMjQxMDcxZTc4NjJiNzhmMTUxMDRj M2JjZWJlYWYxNGQ0ODVhMzEuLjVhNTI1NWM2NDYzOTJiMDk4NjQzNzc5MzAxMTYxMjRlYzg3NTFm ZTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTMtMDItMTQgIEVyaWMgU2VpZGVsICA8ZXJpY0B3 ZWJraXQub3JnPgorCisgICAgICAgIFJFR1JFU1NJT04ocjE0MjcxMik6IGF0dHJpYnV0ZSB2YWx1 ZXMgc2hvdyB1cCBhcyAiKG51bGwpIiBpbnN0ZWFkIG9mIG51bGwgd2l0aCB0aGUgdGhyZWFkZWQg cGFyc2VyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MDk3ODQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBX aGVuIEkgY2hhbmdlZCBtYW55IGNhbGxzaXRlcyB0byB1c2UgdGhlIChleGlzdGluZykgU3RyaW5n KFZlY3RvcikgY29uc3RydWN0b3IKKyAgICAgICAgSSBpbmFkdmVydGFudGx5IG1hZGUgdGhvc2Ug Y2FsbHNpdGVzIGNvbnZlcnQgZW1wdHkgdmVjdG9ycyB0byBudWxsIHN0cmluZ3MKKyAgICAgICAg aW5zdGVhZCBvZiBlbXB0eSBzdHJpbmdzIChsaWtlIFN0cmluZyhVQ2hhcixzaXplX3QpIGRvZXMp LgorCisgICAgICAgIFRoaXMgaXMgZHVlIHRvIGFuIG9kZGl0eS9idWcgaW4gb3VyIFZlY3RvciBp bXBsZW1lbnRhdGlvbiB3aGVyZSBkYXRhKCkKKyAgICAgICAgd2lsbCBiZSAwIGlmIHRoZSBWZWN0 b3IgaXMgZW1wdHksIGJ1dCBvbmx5IGlmIGl0IGRvZXNuJ3QgaGF2ZSBpbmxpbmUgY2FwYWNpdHku CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDk3OTIK KworICAgICAgICBUaGlzIGNoYW5nZXMgU3RyaW5nKFZlY3RvcikgdG8gZXhhY3RseSBtYXRjaCB0 aGUgYmVoYXZpb3Igb2YgU3RyaW5nKHZlY3Rvci5kYXRhKCksIHZlY3Rvci5zaXplKCkpLgorCisg ICAgICAgIFRoaXMgcmVncmVzc2lvbiB3YXMgZWFzaWx5IGRldGVjdGFibGUgd2l0aCB0aGUgdGhy ZWFkZWQgcGFyc2VyLCBiZWNhdXNlIHdlIHVzZSBTdHJpbmcKKyAgICAgICAgaW5zdGVhZCBvZiBB dG9taWNTdHJpbmcgaW4gb3VyIENvbXBhY3RUb2tlbiAodXNlZCB0byBzZW5kIHRoZSBUb2tlbiBk YXRhCisgICAgICAgIGJldHdlZW4gdGhyZWFkcykuICBUaGUgbWFpbi10aHJlYWQgcGFyc2VyIHBh dGggdXNlcyBBdG9taWNIVE1MVG9rZW4gd2hpY2gKKyAgICAgICAgdXNlcyBBdG9taWNTdHJpbmco VmVjdG9yKSBhbmQgZG9lcyBub3QgaGF2ZSB0aGlzIGJ1Zy4KKworICAgICAgICAqIHd0Zi90ZXh0 L1dURlN0cmluZy5oOgorICAgICAgICAoU3RyaW5nKToKKyAgICAgICAgKFdURjo6U3RyaW5nOjpT dHJpbmcpOgorCiAyMDEzLTAyLTEzICBaYW4gRG9iZXJzZWsgIDx6ZG9iZXJzZWtAaWdhbGlhLmNv bT4KIAogICAgICAgICBUaGUgJ2dsb2JhbCBpc2luZi9pc25hbicgY29tcGlsZXIgcXVpcmsgcmVx dWlyZWQgd2hlbiB1c2luZyBjbGFuZyB3aXRoIGxpYnN0ZGMrKwpkaWZmIC0tZ2l0IGEvU291cmNl L1dURi93dGYvdGV4dC9XVEZTdHJpbmcuaCBiL1NvdXJjZS9XVEYvd3RmL3RleHQvV1RGU3RyaW5n LmgKaW5kZXggMGI4NzY5ZDk4MGZkZDc1MzA0N2IxZTFjYWI1ZDNkZWQxMjMyYzA1OC4uNjdlNDVk YzU0MTlkNmVlMTljY2Q4MDYyNDlkZDJkOTE0NDI2ZGI4NyAxMDA2NDQKLS0tIGEvU291cmNlL1dU Ri93dGYvdGV4dC9XVEZTdHJpbmcuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi90ZXh0L1dURlN0cmlu Zy5oCkBAIC0xMTAsNiArMTEwLDkgQEAgcHVibGljOgogCiAgICAgLy8gQ29uc3RydWN0IGEgc3Ry aW5nIGJ5IGNvcHlpbmcgdGhlIGNvbnRlbnRzIG9mIGEgdmVjdG9yLiAgVG8gYXZvaWQKICAgICAv LyBjb3B5aW5nLCBjb25zaWRlciB1c2luZyBTdHJpbmc6OmFkb3B0IGluc3RlYWQuCisgICAgLy8g Q0FVVElPTjogVmVjdG9ycyB3aXRoIHNpemUgMCB3aWxsIHJldHVybiBlbXB0eSBzdHJpbmdzIGlm IHRoZXkgaGF2ZSBpbmxpbmVDYXBhY2l0eQorICAgIC8vIGFuZCBudWxsIHN0cmluZ3MgaWYgdGhl eSBkb24ndC4gVGhpcyBpcyBkdWUgdG8gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTEwOTc5MgorICAgIC8vIGFuZCBpcyBkb25lIHRvIG1hdGNoIFN0cmluZyhVQ2hhcios IHNpemVfdCkgYmVoYXZpb3IuCiAgICAgdGVtcGxhdGU8c2l6ZV90IGlubGluZUNhcGFjaXR5Pgog ICAgIGV4cGxpY2l0IFN0cmluZyhjb25zdCBWZWN0b3I8VUNoYXIsIGlubGluZUNhcGFjaXR5PiYp OwogCkBAIC01MzUsNyArNTM4LDcgQEAgaW5saW5lIHZvaWQgc3dhcChTdHJpbmcmIGEsIFN0cmlu ZyYgYikgeyBhLnN3YXAoYik7IH0KIAogdGVtcGxhdGU8c2l6ZV90IGlubGluZUNhcGFjaXR5Pgog U3RyaW5nOjpTdHJpbmcoY29uc3QgVmVjdG9yPFVDaGFyLCBpbmxpbmVDYXBhY2l0eT4mIHZlY3Rv cikKLSAgICA6IG1faW1wbCh2ZWN0b3Iuc2l6ZSgpID8gU3RyaW5nSW1wbDo6Y3JlYXRlKHZlY3Rv ci5kYXRhKCksIHZlY3Rvci5zaXplKCkpIDogMCkKKyAgICA6IG1faW1wbCh2ZWN0b3IuZGF0YSgp ID8gU3RyaW5nSW1wbDo6Y3JlYXRlKHZlY3Rvci5kYXRhKCksIHZlY3Rvci5zaXplKCkpIDogMCkK IHsKIH0KIAo= 188288 2013-02-14 01:38:54 -0800 2013-02-14 10:26:07 -0800 Patch for landing bug-109784-20130214013522.patch text/plain 2745 eric U3VidmVyc2lvbiBSZXZpc2lvbjogMTQyODU5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGRmMjQxMDcxZTc4NjJiNzhmMTUxMDRj M2JjZWJlYWYxNGQ0ODVhMzEuLmFiNzljNzE1YjEzYTllOTc0YTUxZGUzMmE5M2NkZjBjZjBlNWI1 ODggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTMtMDItMTQgIEVyaWMgU2VpZGVsICA8ZXJpY0B3 ZWJraXQub3JnPgorCisgICAgICAgIFJFR1JFU1NJT04ocjE0MjcxMik6IGF0dHJpYnV0ZSB2YWx1 ZXMgc2hvdyB1cCBhcyAiKG51bGwpIiBpbnN0ZWFkIG9mIG51bGwgd2l0aCB0aGUgdGhyZWFkZWQg cGFyc2VyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MDk3ODQKKworICAgICAgICBSZXZpZXdlZCBieSBCZW5qYW1pbiBQb3VsYWluLgorCisgICAgICAg IFdoZW4gSSBjaGFuZ2VkIG1hbnkgY2FsbHNpdGVzIHRvIHVzZSB0aGUgKGV4aXN0aW5nKSBTdHJp bmcoVmVjdG9yKSBjb25zdHJ1Y3RvcgorICAgICAgICBJIGluYWR2ZXJ0YW50bHkgbWFkZSB0aG9z ZSBjYWxsc2l0ZXMgY29udmVydCBlbXB0eSB2ZWN0b3JzIHRvIG51bGwgc3RyaW5ncworICAgICAg ICBpbnN0ZWFkIG9mIGVtcHR5IHN0cmluZ3MgKGxpa2UgU3RyaW5nKFVDaGFyLHNpemVfdCkgZG9l cykuCisKKyAgICAgICAgVGhpcyBpcyBkdWUgdG8gYW4gb2RkaXR5L2J1ZyBpbiBvdXIgVmVjdG9y IGltcGxlbWVudGF0aW9uIHdoZXJlIGRhdGEoKQorICAgICAgICB3aWxsIGJlIDAgaWYgdGhlIFZl Y3RvciBpcyBlbXB0eSwgYnV0IG9ubHkgaWYgaXQgZG9lc24ndCBoYXZlIGlubGluZSBjYXBhY2l0 eS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwOTc5 MgorCisgICAgICAgIFRoaXMgY2hhbmdlcyBTdHJpbmcoVmVjdG9yKSB0byBleGFjdGx5IG1hdGNo IHRoZSBiZWhhdmlvciBvZiBTdHJpbmcodmVjdG9yLmRhdGEoKSwgdmVjdG9yLnNpemUoKSkuCisK KyAgICAgICAgVGhpcyByZWdyZXNzaW9uIHdhcyBlYXNpbHkgZGV0ZWN0YWJsZSB3aXRoIHRoZSB0 aHJlYWRlZCBwYXJzZXIsIGJlY2F1c2Ugd2UgdXNlIFN0cmluZworICAgICAgICBpbnN0ZWFkIG9m IEF0b21pY1N0cmluZyBpbiBvdXIgQ29tcGFjdFRva2VuICh1c2VkIHRvIHNlbmQgdGhlIFRva2Vu IGRhdGEKKyAgICAgICAgYmV0d2VlbiB0aHJlYWRzKS4gVGhlIG1haW4tdGhyZWFkIHBhcnNlciBw YXRoIHVzZXMgQXRvbWljSFRNTFRva2VuIHdoaWNoCisgICAgICAgIHVzZXMgQXRvbWljU3RyaW5n KFZlY3RvcikgYW5kIGRvZXMgbm90IGhhdmUgdGhpcyBidWcuCisKKyAgICAgICAgKiB3dGYvdGV4 dC9XVEZTdHJpbmcuaDoKKyAgICAgICAgKFN0cmluZyk6CisgICAgICAgIChXVEY6OlN0cmluZzo6 U3RyaW5nKToKKwogMjAxMy0wMi0xMyAgWmFuIERvYmVyc2VrICA8emRvYmVyc2VrQGlnYWxpYS5j b20+CiAKICAgICAgICAgVGhlICdnbG9iYWwgaXNpbmYvaXNuYW4nIGNvbXBpbGVyIHF1aXJrIHJl cXVpcmVkIHdoZW4gdXNpbmcgY2xhbmcgd2l0aCBsaWJzdGRjKysKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XVEYvd3RmL3RleHQvV1RGU3RyaW5nLmggYi9Tb3VyY2UvV1RGL3d0Zi90ZXh0L1dURlN0cmlu Zy5oCmluZGV4IDBiODc2OWQ5ODBmZGQ3NTMwNDdiMWUxY2FiNWQzZGVkMTIzMmMwNTguLjY3ZTQ1 ZGM1NDE5ZDZlZTE5Y2NkODA2MjQ5ZGQyZDkxNDQyNmRiODcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X VEYvd3RmL3RleHQvV1RGU3RyaW5nLmgKKysrIGIvU291cmNlL1dURi93dGYvdGV4dC9XVEZTdHJp bmcuaApAQCAtMTEwLDYgKzExMCw5IEBAIHB1YmxpYzoKIAogICAgIC8vIENvbnN0cnVjdCBhIHN0 cmluZyBieSBjb3B5aW5nIHRoZSBjb250ZW50cyBvZiBhIHZlY3Rvci4gIFRvIGF2b2lkCiAgICAg Ly8gY29weWluZywgY29uc2lkZXIgdXNpbmcgU3RyaW5nOjphZG9wdCBpbnN0ZWFkLgorICAgIC8v IENBVVRJT046IFZlY3RvcnMgd2l0aCBzaXplIDAgd2lsbCByZXR1cm4gZW1wdHkgc3RyaW5ncyBp ZiB0aGV5IGhhdmUgaW5saW5lQ2FwYWNpdHkKKyAgICAvLyBhbmQgbnVsbCBzdHJpbmdzIGlmIHRo ZXkgZG9uJ3QuIFRoaXMgaXMgZHVlIHRvIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xMDk3OTIKKyAgICAvLyBhbmQgaXMgZG9uZSB0byBtYXRjaCBTdHJpbmcoVUNoYXIq LCBzaXplX3QpIGJlaGF2aW9yLgogICAgIHRlbXBsYXRlPHNpemVfdCBpbmxpbmVDYXBhY2l0eT4K ICAgICBleHBsaWNpdCBTdHJpbmcoY29uc3QgVmVjdG9yPFVDaGFyLCBpbmxpbmVDYXBhY2l0eT4m KTsKIApAQCAtNTM1LDcgKzUzOCw3IEBAIGlubGluZSB2b2lkIHN3YXAoU3RyaW5nJiBhLCBTdHJp bmcmIGIpIHsgYS5zd2FwKGIpOyB9CiAKIHRlbXBsYXRlPHNpemVfdCBpbmxpbmVDYXBhY2l0eT4K IFN0cmluZzo6U3RyaW5nKGNvbnN0IFZlY3RvcjxVQ2hhciwgaW5saW5lQ2FwYWNpdHk+JiB2ZWN0 b3IpCi0gICAgOiBtX2ltcGwodmVjdG9yLnNpemUoKSA/IFN0cmluZ0ltcGw6OmNyZWF0ZSh2ZWN0 b3IuZGF0YSgpLCB2ZWN0b3Iuc2l6ZSgpKSA6IDApCisgICAgOiBtX2ltcGwodmVjdG9yLmRhdGEo KSA/IFN0cmluZ0ltcGw6OmNyZWF0ZSh2ZWN0b3IuZGF0YSgpLCB2ZWN0b3Iuc2l6ZSgpKSA6IDAp CiB7CiB9CiAK 188378 2013-02-14 10:26:13 -0800 2013-02-14 11:18:51 -0800 Back to the original fix, now with more context bug-109784-20130214102240.patch text/plain 2795 eric U3VidmVyc2lvbiBSZXZpc2lvbjogMTQyODg5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGFiNzljNzE1YjEzYTllOTc0YTUxZGUz MmE5M2NkZjBjZjBlNWI1ODguLmEyYzUzOGJmZWNiZWQ5MjhkYmQ1NDI3ZThkYmEzMzhmZGIxMDg5 MmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDUgKzEsMjUgQEAKIDIwMTMtMDItMTQgIEVyaWMgU2VpZGVsICA8ZXJpY0B3 ZWJraXQub3JnPgogCisgICAgICAgIFN0cmluZyhWZWN0b3IpIGJlaGF2ZXMgZGlmZmVyZW50bHkg ZnJvbSBTdHJpbmcodmVjdG9yLmRhdGEoKSwgdmVjdG9yLnNpemUoKSkgZm9yIHZlY3RvcnMgd2l0 aCBpbmxpbmUgY2FwYWNpdHkgaW4gdGhlIHNpemU9MCBjYXNlCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDk3ODQKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUaGlzIG1ha2VzIFN0cmluZyhWZWN0b3IpIG5l dmVyIHJldHVybiBudWxsIHN0cmluZ3MuCisgICAgICAgIFdoaWNoIG1hdGNoZXMgYmVoYXZpb3Ig b2YgU3RyaW5nKFVDaGFyKiwgc2l6ZV90KQorICAgICAgICBmb3IgdmVjdG9ycyB3aXRoIGlubGlu ZUNhcGFjaXR5LCBidXQgZGlmZmVycyBmcm9tCisgICAgICAgIFN0cmluZyhVQ2hhciosIHNpemVf dCkgaW4gdGhlIG5vLWlubGluZUNhcGFjaXR5IGNhc2UuCisKKyAgICAgICAgVGhpcyBpbmNpZGVu dGFsbHkgd2lsbCBmaXggYSBiZWhhdmlvcmFsIHJlZ3Jlc3Npb24KKyAgICAgICAgaW4gdGhlIGh0 bWwgdGhyZWFkZWQgcGFyc2VyIHdoaWNoIGNhbWUgZnJvbSBjb252ZXJ0aW5nCisgICAgICAgIG1h bnkgU3RyaW5nKFVDaGFyKiwgc2l6ZV90KSBjYWxsc2l0ZXMgdG8gdXNpbmcgU3RyaW5nKFZlY3Rv cikuCisKKyAgICAgICAgKiB3dGYvdGV4dC9XVEZTdHJpbmcuaDoKKyAgICAgICAgKFN0cmluZyk6 CisgICAgICAgIChXVEY6OlN0cmluZzo6U3RyaW5nKToKKworMjAxMy0wMi0xNCAgRXJpYyBTZWlk ZWwgIDxlcmljQHdlYmtpdC5vcmc+CisKICAgICAgICAgUkVHUkVTU0lPTihyMTQyNzEyKTogYXR0 cmlidXRlIHZhbHVlcyBzaG93IHVwIGFzICIobnVsbCkiIGluc3RlYWQgb2YgbnVsbCB3aXRoIHRo ZSB0aHJlYWRlZCBwYXJzZXIKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTEwOTc4NAogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi90ZXh0L1dURlN0 cmluZy5oIGIvU291cmNlL1dURi93dGYvdGV4dC9XVEZTdHJpbmcuaAppbmRleCA2N2U0NWRjNTQx OWQ2ZWUxOWNjZDgwNjI0OWRkMmQ5MTQ0MjZkYjg3Li41YmQzZGIyOTU5YThkMzI3YmFlNjcxZWIz ZjRiMWMyN2M3Zjc4YTk3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi90ZXh0L1dURlN0cmlu Zy5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL3RleHQvV1RGU3RyaW5nLmgKQEAgLTExMCw5ICsxMTAs MTIgQEAgcHVibGljOgogCiAgICAgLy8gQ29uc3RydWN0IGEgc3RyaW5nIGJ5IGNvcHlpbmcgdGhl IGNvbnRlbnRzIG9mIGEgdmVjdG9yLiAgVG8gYXZvaWQKICAgICAvLyBjb3B5aW5nLCBjb25zaWRl ciB1c2luZyBTdHJpbmc6OmFkb3B0IGluc3RlYWQuCi0gICAgLy8gQ0FVVElPTjogVmVjdG9ycyB3 aXRoIHNpemUgMCB3aWxsIHJldHVybiBlbXB0eSBzdHJpbmdzIGlmIHRoZXkgaGF2ZSBpbmxpbmVD YXBhY2l0eQotICAgIC8vIGFuZCBudWxsIHN0cmluZ3MgaWYgdGhleSBkb24ndC4gVGhpcyBpcyBk dWUgdG8gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwOTc5MgotICAg IC8vIGFuZCBpcyBkb25lIHRvIG1hdGNoIFN0cmluZyhVQ2hhciosIHNpemVfdCkgYmVoYXZpb3Iu CisgICAgLy8gVGhpcyBtZXRob2Qgd2lsbCBuZXZlciBjcmVhdGUgYSBudWxsIHN0cmluZy4gVmVj dG9ycyB3aXRoIHNpemUoKSA9PSAwCisgICAgLy8gd2lsbCByZXR1cm4gdGhlIGVtcHR5IHN0cmlu Zy4KKyAgICAvLyBOT1RFOiBUaGlzIGlzIGRpZmZlcmVudCBmcm9tIFN0cmluZyh2ZWN0b3IuZGF0 YSgpLCB2ZWN0b3Iuc2l6ZSgpKQorICAgIC8vIHdoaWNoIHdpbGwgc29tZXRpbWVzIHJldHVybiBh IG51bGwgc3RyaW5nIHdoZW4gdmVjdG9yLmRhdGEoKSBpcyBudWxsCisgICAgLy8gd2hpY2ggY2Fu IG9ubHkgb2NjdXIgZm9yIHZlY3RvcnMgd2l0aG91dCBpbmxpbmUgY2FwYWNpdHkuCisgICAgLy8g U2VlOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTA5NzkyCiAgICAg dGVtcGxhdGU8c2l6ZV90IGlubGluZUNhcGFjaXR5PgogICAgIGV4cGxpY2l0IFN0cmluZyhjb25z dCBWZWN0b3I8VUNoYXIsIGlubGluZUNhcGFjaXR5PiYpOwogCkBAIC01MzgsNyArNTQxLDcgQEAg aW5saW5lIHZvaWQgc3dhcChTdHJpbmcmIGEsIFN0cmluZyYgYikgeyBhLnN3YXAoYik7IH0KIAog dGVtcGxhdGU8c2l6ZV90IGlubGluZUNhcGFjaXR5PgogU3RyaW5nOjpTdHJpbmcoY29uc3QgVmVj dG9yPFVDaGFyLCBpbmxpbmVDYXBhY2l0eT4mIHZlY3RvcikKLSAgICA6IG1faW1wbCh2ZWN0b3Iu ZGF0YSgpID8gU3RyaW5nSW1wbDo6Y3JlYXRlKHZlY3Rvci5kYXRhKCksIHZlY3Rvci5zaXplKCkp IDogMCkKKyAgICA6IG1faW1wbCh2ZWN0b3Iuc2l6ZSgpID8gU3RyaW5nSW1wbDo6Y3JlYXRlKHZl Y3Rvci5kYXRhKCksIHZlY3Rvci5zaXplKCkpIDogU3RyaW5nSW1wbDo6ZW1wdHkoKSkKIHsKIH0K IAo=