97644 2012-09-26 01:28:17 -0700 Attr.ownerDocument should change if its parent's owner did 2013-01-16 20:24:12 -0800 1 1 1 Unclassified WebKit DOM 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED http://jsfiddle.net/fcy5u/1/ P2 Normal --- 1 morrita morrita ap cmarcelo dglazkov kling koivisto ojan rniwa syoichi webkit.review.bot oldest_to_newest 728307 0 morrita 2012-09-26 01:28:17 -0700 Currently Attr.ownerDocument doesn't change even if its holding element's owner changed. 728309 1 165749 morrita 2012-09-26 01:31:44 -0700 Created attachment 165749 Patch 729709 2 ap 2012-09-27 11:05:19 -0700 This appears to slow down moving elements just to make a very rare operation correct. Would it be possible to change Attr.ownerDocument implementation instead, so that it would get the owner document from element? 729984 3 rniwa 2012-09-27 16:27:15 -0700 (In reply to comment #2) > This appears to slow down moving elements just to make a very rare operation correct. Would it be possible to change Attr.ownerDocument implementation instead, so that it would get the owner document from element? Unfortunately, ownerDocument() is implemented in Node so that doesn't work. On the other hand, I don't expect Attr to exist on most elements so the perf. impact should be minimal. 729987 4 165749 rniwa 2012-09-27 16:31:04 -0700 Comment on attachment 165749 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=165749&action=review > Source/WebCore/dom/TreeScopeAdopter.cpp:65 > + Vector<Attr*> attrs; Do we really need to have a local Vector for this? Attr can only have character data & entities, no? 730082 5 165749 morrita 2012-09-27 18:13:42 -0700 Comment on attachment 165749 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=165749&action=review >> Source/WebCore/dom/TreeScopeAdopter.cpp:65 >> + Vector<Attr*> attrs; > > Do we really need to have a local Vector for this? Attr can only have character data & entities, no? It doesn't matter which item Attr can have. This Attr list is owned by Element and getExistingAttrs() grubs it. We could just return AttrList, which is defined locally in ElementAttributeData.cpp. But it looks we want to hide the implementation detail so I'm doing like this. 730089 6 morrita 2012-09-27 18:20:28 -0700 (In reply to comment #3) > (In reply to comment #2) > > This appears to slow down moving elements just to make a very rare operation correct. Would it be possible to change Attr.ownerDocument implementation instead, so that it would get the owner document from element? > > Unfortunately, ownerDocument() is implemented in Node so that doesn't work. On the other hand, I don't expect Attr to exist on most elements so the perf. impact should be minimal. Yeah, good news is that this doesn't happen in many cases. This path is hit only when the node is moved between document (TreeScope in precise.) Moving XHR.responseXML to the host document would be almost only relevant usecase in the real world, whose performance regression, if any, will be hidden behind network latency. 730106 7 165749 rniwa 2012-09-27 18:51:48 -0700 Comment on attachment 165749 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=165749&action=review >>> Source/WebCore/dom/TreeScopeAdopter.cpp:65 >>> + Vector<Attr*> attrs; >> >> Do we really need to have a local Vector for this? Attr can only have character data & entities, no? > > It doesn't matter which item Attr can have. This Attr list is owned by Element and getExistingAttrs() grubs it. > We could just return AttrList, which is defined locally in ElementAttributeData.cpp. But it looks we want to hide the implementation detail > so I'm doing like this. IMO, encapsulation is not a good enough reason to allocate another Vector. We should just retrieve const Vector<RefPtr<Attr> >& instead. anttik or kling might have a strong opinion here. 730107 8 rniwa 2012-09-27 18:54:05 -0700 Let me phrase it differently. The fact we have a Vector<RefPtr<Attr> > in ElementAttributeData doesn't seem like something we need to hide at the cost of cloning a heap-allocated object. 730108 9 kling 2012-09-27 19:03:26 -0700 (In reply to comment #7) > (From update of attachment 165749 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=165749&action=review > > >>> Source/WebCore/dom/TreeScopeAdopter.cpp:65 > >>> + Vector<Attr*> attrs; > >> > >> Do we really need to have a local Vector for this? Attr can only have character data & entities, no? > > > > It doesn't matter which item Attr can have. This Attr list is owned by Element and getExistingAttrs() grubs it. > > We could just return AttrList, which is defined locally in ElementAttributeData.cpp. But it looks we want to hide the implementation detail > > so I'm doing like this. > > IMO, encapsulation is not a good enough reason to allocate another Vector. > We should just retrieve const Vector<RefPtr<Attr> >& instead. > anttik or kling might have a strong opinion here. No strong opinion, though I guess I'd prefer if we can avoid spreading the implementation details of Attr too much. The API is not part of DOM4, and sees very little use on the current web. 730735 10 ap 2012-09-28 09:36:22 -0700 It may be worth sending a note to webkit-dev to solicit thoughts about performance. 808645 11 165749 darin 2013-01-16 13:12:12 -0800 Comment on attachment 165749 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=165749&action=review > Source/WebCore/dom/TreeScopeAdopter.cpp:51 > if (oldDocument && willMoveToNewDocument) > oldDocument->incDOMTreeVersion(); One thing I don’t like about this TreeScopeAdopter factoring (not new to this patch) is that this one call to incDOMTreeVersion is now here in this file. All the others are in core files like Element.cpp yet this one stray one is out here in the “hinterlands”. Yuck. >>>>> Source/WebCore/dom/TreeScopeAdopter.cpp:65 >>>>> + Vector<Attr*> attrs; >>>> >>>> Do we really need to have a local Vector for this? Attr can only have character data & entities, no? >>> >>> It doesn't matter which item Attr can have. This Attr list is owned by Element and getExistingAttrs() grubs it. >>> We could just return AttrList, which is defined locally in ElementAttributeData.cpp. But it looks we want to hide the implementation detail >>> so I'm doing like this. >> >> IMO, encapsulation is not a good enough reason to allocate another Vector. >> We should just retrieve const Vector<RefPtr<Attr> >& instead. >> anttik or kling might have a strong opinion here. > > No strong opinion, though I guess I'd prefer if we can avoid spreading the implementation details of Attr too much. The API is not part of DOM4, and sees very little use on the current web. It does seem gratuitous to copy the vector just for a slightly larger theoretical level of encapsulation. I agree with Ryosuke that returning a "const Vector<RefPtr<Attr> >&" from an existingAttrs function would be fine. It exposes implementation detail, but in a harmless way that is easy to change later. If the encapsulation really is an issue, then one way to keep tighter encapsulation without copying would be to expose a function, perhaps a template, that applies a passed-in function object to all attrs, then pass it an an object that does this->moveTreeToNewScope(x). But moving a Node between documents that has some associated Attr should be rare enough that I suppose any of these designs would be OK; the performance should not be critical. I wonder how far we are from being able to remove the Attr feature from our engine? That would be the best solution, by far! 808924 12 165749 morrita 2013-01-16 18:11:09 -0800 Comment on attachment 165749 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=165749&action=review >>>>>> Source/WebCore/dom/TreeScopeAdopter.cpp:65 >>>>>> + Vector<Attr*> attrs; >>>>> >>>>> Do we really need to have a local Vector for this? Attr can only have character data & entities, no? >>>> >>>> It doesn't matter which item Attr can have. This Attr list is owned by Element and getExistingAttrs() grubs it. >>>> We could just return AttrList, which is defined locally in ElementAttributeData.cpp. But it looks we want to hide the implementation detail >>>> so I'm doing like this. >>> >>> IMO, encapsulation is not a good enough reason to allocate another Vector. >>> We should just retrieve const Vector<RefPtr<Attr> >& instead. >>> anttik or kling might have a strong opinion here. >> >> No strong opinion, though I guess I'd prefer if we can avoid spreading the implementation details of Attr too much. The API is not part of DOM4, and sees very little use on the current web. > > It does seem gratuitous to copy the vector just for a slightly larger theoretical level of encapsulation. I agree with Ryosuke that returning a "const Vector<RefPtr<Attr> >&" from an existingAttrs function would be fine. It exposes implementation detail, but in a harmless way that is easy to change later. > > If the encapsulation really is an issue, then one way to keep tighter encapsulation without copying would be to expose a function, perhaps a template, that applies a passed-in function object to all attrs, then pass it an an object that does this->moveTreeToNewScope(x). > > But moving a Node between documents that has some associated Attr should be rare enough that I suppose any of these designs would be OK; the performance should not be critical. > > I wonder how far we are from being able to remove the Attr feature from our engine? That would be the best solution, by far! OK, keeping encapsulation here looks overkill. I'll take what Ryosuke is suggesting. 808925 13 183080 morrita 2013-01-16 18:12:21 -0800 Created attachment 183080 Patch for landing 808961 14 183080 webkit.review.bot 2013-01-16 18:42:16 -0800 Comment on attachment 183080 Patch for landing Rejecting attachment 183080 from commit-queue. Failed to run "['/mnt/git/webkit-commit-queue/Tools/Scripts/webkit-patch', '--status-host=queues.webkit.org', '-..." exit_code: 2 cwd: /mnt/git/webkit-commit-queue Last 500 characters of output: rce/WebKit/chromium/webkit/media/crypto/ppapi/cdm --revision 173055 --non-interactive --force --accept theirs-conflict --ignore-externals' in '/mnt/git/webkit-commit-queue/Source/WebKit/chromium' 56>At revision 173055. ________ running '/usr/bin/python tools/clang/scripts/update.py --mac-only' in '/mnt/git/webkit-commit-queue/Source/WebKit/chromium' ________ running '/usr/bin/python gyp_webkit' in '/mnt/git/webkit-commit-queue/Source/WebKit/chromium' Updating webkit projects from gyp files... Full output: http://queues.webkit.org/results/15905711 809000 15 183102 morrita 2013-01-16 19:39:14 -0800 Created attachment 183102 Patch for landing 809013 16 183102 webkit.review.bot 2013-01-16 20:15:01 -0800 Comment on attachment 183102 Patch for landing Rejecting attachment 183102 from commit-queue. Failed to run "['/mnt/git/webkit-commit-queue/Tools/Scripts/webkit-patch', '--status-host=queues.webkit.org', '-..." exit_code: 2 cwd: /mnt/git/webkit-commit-queue Last 500 characters of output: e/WebKit/chromium/third_party/skia/include/core/SkShader.h 50>U /mnt/git/webkit-commit-queue/Source/WebKit/chromium/third_party/skia/include/core/SkTDArray.h 51>Updated to revision 7212. 50>Updated to revision 7212. ________ running '/usr/bin/python tools/clang/scripts/update.py --mac-only' in '/mnt/git/webkit-commit-queue/Source/WebKit/chromium' ________ running '/usr/bin/python gyp_webkit' in '/mnt/git/webkit-commit-queue/Source/WebKit/chromium' Updating webkit projects from gyp files... Full output: http://queues.webkit.org/results/15910732 809015 17 morrita 2013-01-16 20:16:41 -0800 Hmm. cq looks being in trouble. 809017 18 morrita 2013-01-16 20:24:12 -0800 Committed r139958: <http://trac.webkit.org/changeset/139958> 165749 2012-09-26 01:31:44 -0700 2013-01-16 18:12:17 -0800 Patch bug-97644-20120926173103.patch text/plain 6874 morrita U3VidmVyc2lvbiBSZXZpc2lvbjogMTI5NTkzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmUxMjNjZWRhNjdjMTNl MWVmNTBhNjM5YmQ1OWI4ZDhmZGQ1MGFmYy4uYjRjNmQ3ZDBhNmZjZmJkNmVhZDQxYjAzYTFkOWY2 M2ZlZTFjOGQ4NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEyLTA5LTI2ICBNT1JJ VEEgSGFqaW1lICA8bW9ycml0YUBnb29nbGUuY29tPgorCisgICAgICAgIEF0dHIub3duZXJEb2N1 bWVudCBzaG91bGQgY2hhbmdlIGlmIGl0cyBwYXJlbnQncyBvd25lciBkaWQKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk3NjQ0CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgbW92ZVRyZWVUb05ld1Njb3BlKCkg ZGlkbid0IHRyYXZlcnNlIGl0cyBBdHRyIGluc3RhbmNlcy4gQnV0IGl0IHNob3VsZC4KKworICAg ICAgICBUZXN0OiBmYXN0L2RvbS9BdHRyL3BhcmVudC1hZG9wdC1ub2RlLmh0bWwKKworICAgICAg ICAqIGRvbS9FbGVtZW50QXR0cmlidXRlRGF0YS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFbGVt ZW50QXR0cmlidXRlRGF0YTo6Z2V0RXhpc3RpbmdBdHRycyk6CisgICAgICAgIChXZWJDb3JlKToK KyAgICAgICAgKiBkb20vRWxlbWVudEF0dHJpYnV0ZURhdGEuaDoKKyAgICAgICAgKEVsZW1lbnRB dHRyaWJ1dGVEYXRhKToKKyAgICAgICAgKiBkb20vVHJlZVNjb3BlQWRvcHRlci5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpUcmVlU2NvcGVBZG9wdGVyOjptb3ZlVHJlZVRvTmV3U2NvcGUpOgorCiAy MDEyLTA5LTI1ICBZb3NoaWZ1bWkgSW5vdWUgIDx5b3NpbkBjaHJvbWl1bS5vcmc+CiAKICAgICAg ICAgW0Zvcm1zXSBXZSBzaG91bGQgZGlzY29ubmVjdCBEYXRlVGltZUVkaXRFbGVtZW50IGFuZCBE YXRlVGltZUZpZWxkRWxlbWVudCBvbiBsYXlvdXQoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvZG9tL0VsZW1lbnRBdHRyaWJ1dGVEYXRhLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVt ZW50QXR0cmlidXRlRGF0YS5jcHAKaW5kZXggNWE3ZjM0MTI1NGE4NjVhNTUyMzcwNTVhM2JkYmRm YzlmMjRjZWRkNS4uNGFjMjc2OTBmMGY2NjE0ODFhODlkMjliMTJkYTY0YWMwMGQ5NTczNiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnRBdHRyaWJ1dGVEYXRhLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudEF0dHJpYnV0ZURhdGEuY3BwCkBAIC0xNTQsNiAr MTU0LDE0IEBAIFBhc3NSZWZQdHI8QXR0cj4gRWxlbWVudEF0dHJpYnV0ZURhdGE6OmVuc3VyZUF0 dHIoRWxlbWVudCogZWxlbWVudCwgY29uc3QgUXVhbGlmCiAgICAgcmV0dXJuIGF0dHIucmVsZWFz ZSgpOwogfQogCit2b2lkIEVsZW1lbnRBdHRyaWJ1dGVEYXRhOjpnZXRFeGlzdGluZ0F0dHJzKEVs ZW1lbnQqIGVsZW1lbnQsIFZlY3RvcjxBdHRyKj4mIGF0dHJzKSBjb25zdAoreworICAgIEF0dHJM aXN0KiBhdHRyTGlzdCA9IGF0dHJMaXN0Rm9yRWxlbWVudChlbGVtZW50KTsKKyAgICBBU1NFUlQo YXR0ckxpc3QpOworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBhdHRyTGlzdC0+c2l6ZSgp OyArK2kpCisgICAgICAgIGF0dHJzLmFwcGVuZChhdHRyTGlzdC0+YXQoaSkuZ2V0KCkpOworfQor CiB2b2lkIEVsZW1lbnRBdHRyaWJ1dGVEYXRhOjpzZXRBdHRyKEVsZW1lbnQqIGVsZW1lbnQsIGNv bnN0IFF1YWxpZmllZE5hbWUmIG5hbWUsIEF0dHIqIGF0dHIpIGNvbnN0CiB7CiAgICAgQXR0ckxp c3QqIGF0dHJMaXN0ID0gZW5zdXJlQXR0ckxpc3RGb3JFbGVtZW50KGVsZW1lbnQpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnRBdHRyaWJ1dGVEYXRhLmggYi9Tb3VyY2Uv V2ViQ29yZS9kb20vRWxlbWVudEF0dHJpYnV0ZURhdGEuaAppbmRleCA1MGE4NWRjNzY3YzhiMGE2 OTE1ZDM2NzFiY2ZjZDg4Y2U0ZmM0NzE3Li5iYWU3MDE4YzRmZWUwMDBjZTcwMTBkOWI4MGNlZWMz NWYzYzYwM2I3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudEF0dHJpYnV0 ZURhdGEuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudEF0dHJpYnV0ZURhdGEuaApA QCAtOTYsNiArOTYsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCByZW1vdmVBdHRyKEVsZW1lbnQqLCBj b25zdCBRdWFsaWZpZWROYW1lJikgY29uc3Q7CiAgICAgUGFzc1JlZlB0cjxBdHRyPiBhdHRySWZF eGlzdHMoRWxlbWVudCosIGNvbnN0IFF1YWxpZmllZE5hbWUmKSBjb25zdDsKICAgICBQYXNzUmVm UHRyPEF0dHI+IGVuc3VyZUF0dHIoRWxlbWVudCosIGNvbnN0IFF1YWxpZmllZE5hbWUmKSBjb25z dDsKKyAgICB2b2lkIGdldEV4aXN0aW5nQXR0cnMoRWxlbWVudCosIFZlY3RvcjxBdHRyKj4mKSBj b25zdDsKICAgICB2b2lkIGRldGFjaEF0dHJPYmplY3RzRnJvbUVsZW1lbnQoRWxlbWVudCopIGNv bnN0OwogCiAgICAgdm9pZCByZXBvcnRNZW1vcnlVc2FnZShNZW1vcnlPYmplY3RJbmZvKikgY29u c3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vVHJlZVNjb3BlQWRvcHRlci5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9kb20vVHJlZVNjb3BlQWRvcHRlci5jcHAKaW5kZXggMzYwMWUwODU5 OGI1N2MwNGRmMTMzY2Q0MTA4ZTRkMmViZTlmYjViOC4uYmJjMGVmOWM0ODBkYTNmNjQwY2NkNTE1 Y2Q0MmRkNDhkYzIzN2MyMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL1RyZWVTY29w ZUFkb3B0ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9UcmVlU2NvcGVBZG9wdGVyLmNw cApAQCAtMjUsNiArMjUsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIlRyZWVT Y29wZUFkb3B0ZXIuaCIKIAorI2luY2x1ZGUgIkF0dHIuaCIKICNpbmNsdWRlICJEb2N1bWVudC5o IgogI2luY2x1ZGUgIkVsZW1lbnRSYXJlRGF0YS5oIgogI2luY2x1ZGUgIkVsZW1lbnRTaGFkb3cu aCIKQEAgLTQ0LDEyICs0NSwxMyBAQCB2b2lkIFRyZWVTY29wZUFkb3B0ZXI6Om1vdmVUcmVlVG9O ZXdTY29wZShOb2RlKiByb290KSBjb25zdAogICAgIC8vIHdlIGVuc3VyZSB0aGF0IHRoZSBjb2xs ZWN0aW9uIGNhY2hlIHdpbGwgYmUgaW52YWxpZGF0ZWQgYXMgbmVlZGVkIHdoZW4gdGhlIGVsZW1l bnQgaXMgbW92ZWQgYmFjay4KICAgICBEb2N1bWVudCogb2xkRG9jdW1lbnQgPSBtX29sZFNjb3Bl ID8gbV9vbGRTY29wZS0+cm9vdE5vZGUoKS0+ZG9jdW1lbnQoKSA6IDA7CiAgICAgRG9jdW1lbnQq IG5ld0RvY3VtZW50ID0gbV9uZXdTY29wZS0+cm9vdE5vZGUoKS0+ZG9jdW1lbnQoKTsKKyAgICBU cmVlU2NvcGUqIG5ld1Njb3BlVG9TZXQgPSBuZXdEb2N1bWVudCA9PSBtX25ld1Njb3BlID8gMCA6 IG1fbmV3U2NvcGU7CiAgICAgYm9vbCB3aWxsTW92ZVRvTmV3RG9jdW1lbnQgPSBvbGREb2N1bWVu dCAhPSBuZXdEb2N1bWVudDsKICAgICBpZiAob2xkRG9jdW1lbnQgJiYgd2lsbE1vdmVUb05ld0Rv Y3VtZW50KQogICAgICAgICBvbGREb2N1bWVudC0+aW5jRE9NVHJlZVZlcnNpb24oKTsKIAogICAg IGZvciAoTm9kZSogbm9kZSA9IHJvb3Q7IG5vZGU7IG5vZGUgPSBub2RlLT50cmF2ZXJzZU5leHRO b2RlKHJvb3QpKSB7Ci0gICAgICAgIGlmIChOb2RlUmFyZURhdGEqIHJhcmVEYXRhID0gbm9kZS0+ c2V0VHJlZVNjb3BlKG5ld0RvY3VtZW50ID09IG1fbmV3U2NvcGUgPyAwIDogbV9uZXdTY29wZSkp IHsKKyAgICAgICAgaWYgKE5vZGVSYXJlRGF0YSogcmFyZURhdGEgPSBub2RlLT5zZXRUcmVlU2Nv cGUobmV3U2NvcGVUb1NldCkpIHsKICAgICAgICAgICAgIGlmIChyYXJlRGF0YS0+bm9kZUxpc3Rz KCkpCiAgICAgICAgICAgICAgICAgcmFyZURhdGEtPm5vZGVMaXN0cygpLT5hZG9wdFRyZWVTY29w ZShvbGREb2N1bWVudCwgbmV3RG9jdW1lbnQpOwogICAgICAgICAgICAgaWYgKG5vZGUtPmlzRWxl bWVudE5vZGUoKSkKQEAgLTU4LDYgKzYwLDE0IEBAIHZvaWQgVHJlZVNjb3BlQWRvcHRlcjo6bW92 ZVRyZWVUb05ld1Njb3BlKE5vZGUqIHJvb3QpIGNvbnN0CiAKICAgICAgICAgaWYgKHdpbGxNb3Zl VG9OZXdEb2N1bWVudCkKICAgICAgICAgICAgIG1vdmVOb2RlVG9OZXdEb2N1bWVudChub2RlLCBv bGREb2N1bWVudCwgbmV3RG9jdW1lbnQpOworICAgICAgICAKKyAgICAgICAgaWYgKG5vZGUtPmhh c0F0dHJMaXN0KCkpIHsKKyAgICAgICAgICAgIFZlY3RvcjxBdHRyKj4gYXR0cnM7CisgICAgICAg ICAgICBFbGVtZW50KiBlbGVtZW50ID0gdG9FbGVtZW50KG5vZGUpOworICAgICAgICAgICAgZWxl bWVudC0+YXR0cmlidXRlRGF0YSgpLT5nZXRFeGlzdGluZ0F0dHJzKGVsZW1lbnQsIGF0dHJzKTsK KyAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBhdHRycy5zaXplKCk7ICsraSkK KyAgICAgICAgICAgICAgICBtb3ZlVHJlZVRvTmV3U2NvcGUoYXR0cnNbaV0pOworICAgICAgICB9 CiAKICAgICAgICAgZm9yIChTaGFkb3dSb290KiBzaGFkb3cgPSBub2RlLT55b3VuZ2VzdFNoYWRv d1Jvb3QoKTsgc2hhZG93OyBzaGFkb3cgPSBzaGFkb3ctPm9sZGVyU2hhZG93Um9vdCgpKSB7CiAg ICAgICAgICAgICBzaGFkb3ctPnNldFBhcmVudFRyZWVTY29wZShtX25ld1Njb3BlKTsKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRl eCBiYzg0NGRhNTdiODljNDk1ZWRkOTJkNzFmYjRkNjFiYWU0OWM3OWI4Li42YWZiZTA0YTMyYzdm OTk1ODM2NWRmNTRkOWY3ZGQ0YjBhN2JmOWY3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTIt MDktMjYgIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdvb2dsZS5jb20+CisKKyAgICAgICAgQXR0 ci5vd25lckRvY3VtZW50IHNob3VsZCBjaGFuZ2UgaWYgaXRzIHBhcmVudCdzIG93bmVyIGRpZAor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTc2NDQKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRpdGlvbmFs IGluZm9ybWF0aW9uIG9mIHRoZSBjaGFuZ2Ugc3VjaCBhcyBhcHByb2FjaCwgcmF0aW9uYWxlLiBQ bGVhc2UgYWRkIHBlci1mdW5jdGlvbiBkZXNjcmlwdGlvbnMgYmVsb3cgKE9PUFMhKS4KKworICAg ICAgICAqIGZhc3QvZG9tL0F0dHIvcGFyZW50LWFkb3B0LW5vZGUtZXhwZWN0ZWQudHh0OiBBZGRl ZC4KKyAgICAgICAgKiBmYXN0L2RvbS9BdHRyL3BhcmVudC1hZG9wdC1ub2RlLmh0bWw6IEFkZGVk LgorCiAyMDEyLTA5LTI1ICBHYXZpbiBCYXJyYWNsb3VnaCAgPGJhcnJhY2xvdWdoQGFwcGxlLmNv bT4KIAogICAgICAgICBSRUdSRVNTSU9OIChyMTI5NDU2KTogaHR0cC90ZXN0cy9zZWN1cml0eS94 c3MtZXZhbC5odG1sIGlzIGZhaWxpbmcgb24gSlNDIHBsYXRmb3JtcwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9kb20vQXR0ci9wYXJlbnQtYWRvcHQtbm9kZS1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9BdHRyL3BhcmVudC1hZG9wdC1ub2RlLWV4cGVjdGVkLnR4dApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5lYjI1ODBkYjNlZDBhZGQ0M2IzZDQ5MTMyY2UxMmUxMGRhNDU5NjY4Ci0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vQXR0ci9wYXJlbnQtYWRvcHQtbm9k ZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw1IEBACitQQVNTIGF0dHIub3duZXJEb2N1bWVudC50 aXRsZSBpcyBhbm90aGVyRG9jdW1lbnQudGl0bGUKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlz IHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Rv bS9BdHRyL3BhcmVudC1hZG9wdC1ub2RlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9BdHRy L3BhcmVudC1hZG9wdC1ub2RlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjhkMTgyMDkwYTg2YTA0OTU3ZGZm ZDY4Njg5YWIwNWM1MmZhMjA1ZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0F0dHIvcGFyZW50LWFkb3B0LW5vZGUuaHRtbApAQCAtMCwwICsxLDE4IEBACis8IURPQ1RZ UEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2Vz L2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPGRpdiBpZD0idGFy Z2V0Ij48L2Rpdj4KKzxzY3JpcHQ+Cit2YXIgdGFyZ2V0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInRhcmdldCIpOwordmFyIGF0dHIgPSB0YXJnZXQuYXR0cmlidXRlc1swXTsKK3ZhciBhbm90 aGVyRG9jdW1lbnQgPSBkb2N1bWVudC5pbXBsZW1lbnRhdGlvbi5jcmVhdGVEb2N1bWVudCgiaHR0 cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCIsICIiLCBudWxsKTsKK2Fub3RoZXJEb2N1bWVudC50 aXRsZSA9ICJIZWxsbyI7Cithbm90aGVyRG9jdW1lbnQuYWRvcHROb2RlKHRhcmdldCk7CitzaG91 bGRCZSgiYXR0ci5vd25lckRvY3VtZW50LnRpdGxlIiwgImFub3RoZXJEb2N1bWVudC50aXRsZSIp OworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9z dC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 183080 2013-01-16 18:12:21 -0800 2013-01-16 19:39:10 -0800 Patch for landing bug-97644-20130117110922.patch text/plain 5551 morrita U3VidmVyc2lvbiBSZXZpc2lvbjogMTM5OTM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWNlMjNkNmIyODYyNWUz YzE2MGI2NjQyNjU1ODMzMTFiOGQzMzY0MS4uNWUxZWUyNDIwZTEyZDM2YTMzZDQ4ZTk3YTYzMTM5 M2Y0NGNmYTA3NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEzLTAxLTE2ICBNT1JJ VEEgSGFqaW1lICA8bW9ycml0YUBnb29nbGUuY29tPgorCisgICAgICAgIEF0dHIub3duZXJEb2N1 bWVudCBzaG91bGQgY2hhbmdlIGlmIGl0cyBwYXJlbnQncyBvd25lciBkaWQKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk3NjQ0CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgbW92ZVRyZWVUb05ld1Njb3BlKCkgZGlk bid0IHRyYXZlcnNlIGl0cyBBdHRyIGluc3RhbmNlcy4gQnV0IGl0IHNob3VsZC4KKworICAgICAg ICBUZXN0OiBmYXN0L2RvbS9BdHRyL3BhcmVudC1hZG9wdC1ub2RlLmh0bWwKKworICAgICAgICAq IGRvbS9FbGVtZW50QXR0cmlidXRlRGF0YS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFbGVtZW50 QXR0cmlidXRlRGF0YTo6Z2V0RXhpc3RpbmdBdHRycyk6CisgICAgICAgIChXZWJDb3JlKToKKyAg ICAgICAgKiBkb20vRWxlbWVudEF0dHJpYnV0ZURhdGEuaDoKKyAgICAgICAgKEVsZW1lbnRBdHRy aWJ1dGVEYXRhKToKKyAgICAgICAgKiBkb20vVHJlZVNjb3BlQWRvcHRlci5jcHA6CisgICAgICAg IChXZWJDb3JlOjpUcmVlU2NvcGVBZG9wdGVyOjptb3ZlVHJlZVRvTmV3U2NvcGUpOgorCiAyMDEz LTAxLTE2ICBFbGxpb3R0IFNwcmVobiAgPGVzcHJlaG5AY2hyb21pdW0ub3JnPgogCiAgICAgICAg IEN1cnNvciBzdG9wcyBibGlua2luZyBhZnRlciBjbGlja2luZyBvbiBzY3JvbGxiYXIKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2Rv bS9FbGVtZW50LmNwcAppbmRleCBmY2QwY2RmNDUzZTlmZDI3MDhlZDIzZTdhYzQ0OTNiODI2OWE0 M2ExLi5jNjllYTNiYWY2MmFiZGQxN2NiMWQwNGFlZjIwNGZiMmY2MzVhMjQ4IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9t L0VsZW1lbnQuY3BwCkBAIC0xNjQyLDYgKzE2NDIsMTIgQEAgdm9pZCBFbGVtZW50Ojpmb3JtYXRG b3JEZWJ1Z2dlcihjaGFyKiBidWZmZXIsIHVuc2lnbmVkIGxlbmd0aCkgY29uc3QKIH0KICNlbmRp ZgogCitjb25zdCBWZWN0b3I8UmVmUHRyPEF0dHI+ID4mIEVsZW1lbnQ6OmF0dHJOb2RlTGlzdCgp Cit7CisgICAgQVNTRVJUKGhhc1N5bnRoZXRpY0F0dHJDaGlsZE5vZGVzKCkpOworICAgIHJldHVy biAqYXR0ck5vZGVMaXN0Rm9yRWxlbWVudCh0aGlzKTsKK30KKwogUGFzc1JlZlB0cjxBdHRyPiBF bGVtZW50OjpzZXRBdHRyaWJ1dGVOb2RlKEF0dHIqIGF0dHJOb2RlLCBFeGNlcHRpb25Db2RlJiBl YykKIHsKICAgICBpZiAoIWF0dHJOb2RlKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9k b20vRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnQuaAppbmRleCAwYmE1NGQy NzAzZWQyNmQ5MmY0YzRkZDc3ZGEyZWM4MTBhODc0MDRlLi4zOGZlMmZiMDZiOTY3Yjk0ZmI5MTEx MWU3ZTAyOTBjZDYyN2YxZmFiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVu dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmgKQEAgLTM3LDYgKzM3LDcgQEAK IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitjbGFzcyBBdHRyOwogY2xhc3MgQXR0cmlidXRlOwog Y2xhc3MgQ2xpZW50UmVjdDsKIGNsYXNzIENsaWVudFJlY3RMaXN0OwpAQCAtMjI4LDcgKzIyOSw5 IEBAIHB1YmxpYzoKIAogICAgIFBhc3NSZWZQdHI8QXR0cj4gYXR0cklmRXhpc3RzKGNvbnN0IFF1 YWxpZmllZE5hbWUmKTsKICAgICBQYXNzUmVmUHRyPEF0dHI+IGVuc3VyZUF0dHIoY29uc3QgUXVh bGlmaWVkTmFtZSYpOwotICAgIAorCisgICAgY29uc3QgVmVjdG9yPFJlZlB0cjxBdHRyPiA+JiBh dHRyTm9kZUxpc3QoKTsKKwogICAgIHZpcnR1YWwgQ1NTU3R5bGVEZWNsYXJhdGlvbiogc3R5bGUo KTsKIAogICAgIGNvbnN0IFF1YWxpZmllZE5hbWUmIHRhZ1FOYW1lKCkgY29uc3QgeyByZXR1cm4g bV90YWdOYW1lOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vVHJlZVNjb3BlQWRv cHRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vVHJlZVNjb3BlQWRvcHRlci5jcHAKaW5kZXgg NGJlNmY5NzliY2RjMDFmMTJiNjlkYWIxMmY2NzBhMjYyNzM0N2U0Ny4uMWNmODUxNTYwZjU1MWNk ODYxOTRhNGYyYThiMjQ5ODcyMjI3Yjc3YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9t L1RyZWVTY29wZUFkb3B0ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9UcmVlU2NvcGVB ZG9wdGVyLmNwcApAQCAtMjUsNiArMjUsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIlRyZWVTY29wZUFkb3B0ZXIuaCIKIAorI2luY2x1ZGUgIkF0dHIuaCIKICNpbmNsdWRlICJE b2N1bWVudC5oIgogI2luY2x1ZGUgIkVsZW1lbnRSYXJlRGF0YS5oIgogI2luY2x1ZGUgIkVsZW1l bnRTaGFkb3cuaCIKQEAgLTYxLDYgKzYyLDE1IEBAIHZvaWQgVHJlZVNjb3BlQWRvcHRlcjo6bW92 ZVRyZWVUb05ld1Njb3BlKE5vZGUqIHJvb3QpIGNvbnN0CiAgICAgICAgIGlmICh3aWxsTW92ZVRv TmV3RG9jdW1lbnQpCiAgICAgICAgICAgICBtb3ZlTm9kZVRvTmV3RG9jdW1lbnQobm9kZSwgb2xk RG9jdW1lbnQsIG5ld0RvY3VtZW50KTsKIAorICAgICAgICBpZiAoIW5vZGUtPmlzRWxlbWVudE5v ZGUoKSkKKyAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgIGlmIChub2RlLT5oYXNTeW50 aGV0aWNBdHRyQ2hpbGROb2RlcygpKSB7CisgICAgICAgICAgICBjb25zdCBWZWN0b3I8UmVmUHRy PEF0dHI+ID4mIGF0dHJzID0gdG9FbGVtZW50KG5vZGUpLT5hdHRyTm9kZUxpc3QoKTsKKyAgICAg ICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBhdHRycy5zaXplKCk7ICsraSkKKyAgICAg ICAgICAgICAgICBtb3ZlVHJlZVRvTmV3U2NvcGUoYXR0cnNbaV0uZ2V0KCkpOworICAgICAgICB9 CisKICAgICAgICAgZm9yIChTaGFkb3dSb290KiBzaGFkb3cgPSBub2RlLT55b3VuZ2VzdFNoYWRv d1Jvb3QoKTsgc2hhZG93OyBzaGFkb3cgPSBzaGFkb3ctPm9sZGVyU2hhZG93Um9vdCgpKSB7CiAg ICAgICAgICAgICBzaGFkb3ctPnNldFBhcmVudFRyZWVTY29wZShtX25ld1Njb3BlKTsKICAgICAg ICAgICAgIGlmICh3aWxsTW92ZVRvTmV3RG9jdW1lbnQpCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggNWI2OGQyZTkwYjUwZjIw ZTQxOGZiZThmMWMwMzgxNGQyMDkxOWE3Mi4uMjE0MzY5ZmYxZWNjZjU0MDc1Y2MyNDUyMGZiYzIx MDNmOTA2NWRkOSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91 dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEzLTAxLTE2ICBNT1JJVEEgSGFq aW1lICA8bW9ycml0YUBnb29nbGUuY29tPgorCisgICAgICAgIEF0dHIub3duZXJEb2N1bWVudCBz aG91bGQgY2hhbmdlIGlmIGl0cyBwYXJlbnQncyBvd25lciBkaWQKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk3NjQ0CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgQWRkaXRpb25hbCBpbmZvcm1hdGlvbiBvZiB0aGUg Y2hhbmdlIHN1Y2ggYXMgYXBwcm9hY2gsIHJhdGlvbmFsZS4gUGxlYXNlIGFkZCBwZXItZnVuY3Rp b24gZGVzY3JpcHRpb25zIGJlbG93IChPT1BTISkuCisKKyAgICAgICAgKiBmYXN0L2RvbS9BdHRy L3BhcmVudC1hZG9wdC1ub2RlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9k b20vQXR0ci9wYXJlbnQtYWRvcHQtbm9kZS5odG1sOiBBZGRlZC4KKwogMjAxMy0wMS0xNiAgVmlj dG9yIENhcmJ1bmUgIDx2Y2FyYnVuZUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgQ3VlcyBub3Qg cmVuZGVyZWQgd2hlbiB0aGV5IHNob3VsZCBiZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC9kb20vQXR0ci9wYXJlbnQtYWRvcHQtbm9kZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9m YXN0L2RvbS9BdHRyL3BhcmVudC1hZG9wdC1ub2RlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5l YjI1ODBkYjNlZDBhZGQ0M2IzZDQ5MTMyY2UxMmUxMGRhNDU5NjY4Ci0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vQXR0ci9wYXJlbnQtYWRvcHQtbm9kZS1leHBlY3RlZC50 eHQKQEAgLTAsMCArMSw1IEBACitQQVNTIGF0dHIub3duZXJEb2N1bWVudC50aXRsZSBpcyBhbm90 aGVyRG9jdW1lbnQudGl0bGUKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVT VCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9BdHRyL3BhcmVu dC1hZG9wdC1ub2RlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9BdHRyL3BhcmVudC1hZG9w dC1ub2RlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjhkMTgyMDkwYTg2YTA0OTU3ZGZmZDY4Njg5YWIwNWM1 MmZhMjA1ZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0F0dHIvcGFy ZW50LWFkb3B0LW5vZGUuaHRtbApAQCAtMCwwICsxLDE4IEBACis8IURPQ1RZUEUgaHRtbD4KKzxo dG1sPgorPGhlYWQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJl LmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPGRpdiBpZD0idGFyZ2V0Ij48L2Rpdj4K KzxzY3JpcHQ+Cit2YXIgdGFyZ2V0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIp OwordmFyIGF0dHIgPSB0YXJnZXQuYXR0cmlidXRlc1swXTsKK3ZhciBhbm90aGVyRG9jdW1lbnQg PSBkb2N1bWVudC5pbXBsZW1lbnRhdGlvbi5jcmVhdGVEb2N1bWVudCgiaHR0cDovL3d3dy53My5v cmcvMTk5OS94aHRtbCIsICIiLCBudWxsKTsKK2Fub3RoZXJEb2N1bWVudC50aXRsZSA9ICJIZWxs byI7Cithbm90aGVyRG9jdW1lbnQuYWRvcHROb2RlKHRhcmdldCk7CitzaG91bGRCZSgiYXR0ci5v d25lckRvY3VtZW50LnRpdGxlIiwgImFub3RoZXJEb2N1bWVudC50aXRsZSIpOworPC9zY3JpcHQ+ Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3Jp cHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 183102 2013-01-16 19:39:14 -0800 2013-01-16 20:15:01 -0800 Patch for landing bug-97644-20130117123615.patch text/plain 5537 morrita U3VidmVyc2lvbiBSZXZpc2lvbjogMTM5OTUyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGEyODlhZDdjOTVjNGRj OTI2OGViYzFjNmE5M2MzYzYyZDA0NDAwYi4uNjRiZDQwNzBlNjRjMjRkZTlhNGQ4MjI5MDRlNThl OTY0N2M0ZTlkYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEzLTAxLTE2ICBNT1JJ VEEgSGFqaW1lICA8bW9ycml0YUBnb29nbGUuY29tPgorCisgICAgICAgIEF0dHIub3duZXJEb2N1 bWVudCBzaG91bGQgY2hhbmdlIGlmIGl0cyBwYXJlbnQncyBvd25lciBkaWQKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk3NjQ0CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgbW92ZVRyZWVUb05ld1Njb3BlKCkgZGlk bid0IHRyYXZlcnNlIGl0cyBBdHRyIGluc3RhbmNlcy4gQnV0IGl0IHNob3VsZC4KKworICAgICAg ICBUZXN0OiBmYXN0L2RvbS9BdHRyL3BhcmVudC1hZG9wdC1ub2RlLmh0bWwKKworICAgICAgICAq IGRvbS9FbGVtZW50QXR0cmlidXRlRGF0YS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFbGVtZW50 QXR0cmlidXRlRGF0YTo6Z2V0RXhpc3RpbmdBdHRycyk6CisgICAgICAgIChXZWJDb3JlKToKKyAg ICAgICAgKiBkb20vRWxlbWVudEF0dHJpYnV0ZURhdGEuaDoKKyAgICAgICAgKEVsZW1lbnRBdHRy aWJ1dGVEYXRhKToKKyAgICAgICAgKiBkb20vVHJlZVNjb3BlQWRvcHRlci5jcHA6CisgICAgICAg IChXZWJDb3JlOjpUcmVlU2NvcGVBZG9wdGVyOjptb3ZlVHJlZVRvTmV3U2NvcGUpOgorCiAyMDEz LTAxLTE2ICBSb2dlciBGb25nICA8cm9nZXJfZm9uZ0BhcHBsZS5jb20+CiAKICAgICAgICAgVW5y ZXZpZXdlZCBidWlsZCBmaXggZm9sbG93aW5nIHIxMzk5MTguCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9kb20vRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5jcHAK aW5kZXggZmNkMGNkZjQ1M2U5ZmQyNzA4ZWQyM2U3YWM0NDkzYjgyNjlhNDNhMS4uYzY5ZWEzYmFm NjJhYmRkMTdjYjFkMDRhZWYyMDRmYjJmNjM1YTI0OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvZG9tL0VsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmNwcApA QCAtMTY0Miw2ICsxNjQyLDEyIEBAIHZvaWQgRWxlbWVudDo6Zm9ybWF0Rm9yRGVidWdnZXIoY2hh ciogYnVmZmVyLCB1bnNpZ25lZCBsZW5ndGgpIGNvbnN0CiB9CiAjZW5kaWYKIAorY29uc3QgVmVj dG9yPFJlZlB0cjxBdHRyPiA+JiBFbGVtZW50OjphdHRyTm9kZUxpc3QoKQoreworICAgIEFTU0VS VChoYXNTeW50aGV0aWNBdHRyQ2hpbGROb2RlcygpKTsKKyAgICByZXR1cm4gKmF0dHJOb2RlTGlz dEZvckVsZW1lbnQodGhpcyk7Cit9CisKIFBhc3NSZWZQdHI8QXR0cj4gRWxlbWVudDo6c2V0QXR0 cmlidXRlTm9kZShBdHRyKiBhdHRyTm9kZSwgRXhjZXB0aW9uQ29kZSYgZWMpCiB7CiAgICAgaWYg KCFhdHRyTm9kZSkgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnQuaCBi L1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmgKaW5kZXggMGJhNTRkMjcwM2VkMjZkOTJmNGM0 ZGQ3N2RhMmVjODEwYTg3NDA0ZS4uMzhmZTJmYjA2Yjk2N2I5NGZiOTExMTFlN2UwMjkwY2Q2Mjdm MWZhYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnQuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9kb20vRWxlbWVudC5oCkBAIC0zNyw2ICszNyw3IEBACiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAorY2xhc3MgQXR0cjsKIGNsYXNzIEF0dHJpYnV0ZTsKIGNsYXNzIENsaWVudFJl Y3Q7CiBjbGFzcyBDbGllbnRSZWN0TGlzdDsKQEAgLTIyOCw3ICsyMjksOSBAQCBwdWJsaWM6CiAK ICAgICBQYXNzUmVmUHRyPEF0dHI+IGF0dHJJZkV4aXN0cyhjb25zdCBRdWFsaWZpZWROYW1lJik7 CiAgICAgUGFzc1JlZlB0cjxBdHRyPiBlbnN1cmVBdHRyKGNvbnN0IFF1YWxpZmllZE5hbWUmKTsK LSAgICAKKworICAgIGNvbnN0IFZlY3RvcjxSZWZQdHI8QXR0cj4gPiYgYXR0ck5vZGVMaXN0KCk7 CisKICAgICB2aXJ0dWFsIENTU1N0eWxlRGVjbGFyYXRpb24qIHN0eWxlKCk7CiAKICAgICBjb25z dCBRdWFsaWZpZWROYW1lJiB0YWdRTmFtZSgpIGNvbnN0IHsgcmV0dXJuIG1fdGFnTmFtZTsgfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1RyZWVTY29wZUFkb3B0ZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvZG9tL1RyZWVTY29wZUFkb3B0ZXIuY3BwCmluZGV4IDRiZTZmOTc5YmNkYzAx ZjEyYjY5ZGFiMTJmNjcwYTI2MjczNDdlNDcuLjFjZjg1MTU2MGY1NTFjZDg2MTk0YTRmMmE4YjI0 OTg3MjIyN2I3N2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9UcmVlU2NvcGVBZG9w dGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vVHJlZVNjb3BlQWRvcHRlci5jcHAKQEAg LTI1LDYgKzI1LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJUcmVlU2NvcGVB ZG9wdGVyLmgiCiAKKyNpbmNsdWRlICJBdHRyLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNp bmNsdWRlICJFbGVtZW50UmFyZURhdGEuaCIKICNpbmNsdWRlICJFbGVtZW50U2hhZG93LmgiCkBA IC02MSw2ICs2MiwxNSBAQCB2b2lkIFRyZWVTY29wZUFkb3B0ZXI6Om1vdmVUcmVlVG9OZXdTY29w ZShOb2RlKiByb290KSBjb25zdAogICAgICAgICBpZiAod2lsbE1vdmVUb05ld0RvY3VtZW50KQog ICAgICAgICAgICAgbW92ZU5vZGVUb05ld0RvY3VtZW50KG5vZGUsIG9sZERvY3VtZW50LCBuZXdE b2N1bWVudCk7CiAKKyAgICAgICAgaWYgKCFub2RlLT5pc0VsZW1lbnROb2RlKCkpCisgICAgICAg ICAgICBjb250aW51ZTsKKworICAgICAgICBpZiAobm9kZS0+aGFzU3ludGhldGljQXR0ckNoaWxk Tm9kZXMoKSkgeworICAgICAgICAgICAgY29uc3QgVmVjdG9yPFJlZlB0cjxBdHRyPiA+JiBhdHRy cyA9IHRvRWxlbWVudChub2RlKS0+YXR0ck5vZGVMaXN0KCk7CisgICAgICAgICAgICBmb3IgKHVu c2lnbmVkIGkgPSAwOyBpIDwgYXR0cnMuc2l6ZSgpOyArK2kpCisgICAgICAgICAgICAgICAgbW92 ZVRyZWVUb05ld1Njb3BlKGF0dHJzW2ldLmdldCgpKTsKKyAgICAgICAgfQorCiAgICAgICAgIGZv ciAoU2hhZG93Um9vdCogc2hhZG93ID0gbm9kZS0+eW91bmdlc3RTaGFkb3dSb290KCk7IHNoYWRv dzsgc2hhZG93ID0gc2hhZG93LT5vbGRlclNoYWRvd1Jvb3QoKSkgewogICAgICAgICAgICAgc2hh ZG93LT5zZXRQYXJlbnRUcmVlU2NvcGUobV9uZXdTY29wZSk7CiAgICAgICAgICAgICBpZiAod2ls bE1vdmVUb05ld0RvY3VtZW50KQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDViNjhkMmU5MGI1MGYyMGU0MThmYmU4ZjFjMDM4 MTRkMjA5MTlhNzIuLjIxNDM2OWZmMWVjY2Y1NDA3NWNjMjQ1MjBmYmMyMTAzZjkwNjVkZDkgMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMy0wMS0xNiAgTU9SSVRBIEhhamltZSAgPG1vcnJpdGFA Z29vZ2xlLmNvbT4KKworICAgICAgICBBdHRyLm93bmVyRG9jdW1lbnQgc2hvdWxkIGNoYW5nZSBp ZiBpdHMgcGFyZW50J3Mgb3duZXIgZGlkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD05NzY0NAorCisgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVy LgorCisgICAgICAgIEFkZGl0aW9uYWwgaW5mb3JtYXRpb24gb2YgdGhlIGNoYW5nZSBzdWNoIGFz IGFwcHJvYWNoLCByYXRpb25hbGUuIFBsZWFzZSBhZGQgcGVyLWZ1bmN0aW9uIGRlc2NyaXB0aW9u cyBiZWxvdyAoT09QUyEpLgorCisgICAgICAgICogZmFzdC9kb20vQXR0ci9wYXJlbnQtYWRvcHQt bm9kZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0F0dHIvcGFyZW50 LWFkb3B0LW5vZGUuaHRtbDogQWRkZWQuCisKIDIwMTMtMDEtMTYgIFZpY3RvciBDYXJidW5lICA8 dmNhcmJ1bmVAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIEN1ZXMgbm90IHJlbmRlcmVkIHdoZW4g dGhleSBzaG91bGQgYmUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0F0dHIvcGFy ZW50LWFkb3B0LW5vZGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vQXR0ci9w YXJlbnQtYWRvcHQtbm9kZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZWIyNTgwZGIzZWQwYWRk NDNiM2Q0OTEzMmNlMTJlMTBkYTQ1OTY2OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2Zhc3QvZG9tL0F0dHIvcGFyZW50LWFkb3B0LW5vZGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEs NSBAQAorUEFTUyBhdHRyLm93bmVyRG9jdW1lbnQudGl0bGUgaXMgYW5vdGhlckRvY3VtZW50LnRp dGxlCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vQXR0ci9wYXJlbnQtYWRvcHQtbm9kZS5o dG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vQXR0ci9wYXJlbnQtYWRvcHQtbm9kZS5odG1sCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjY4ZDE4MjA5MGE4NmEwNDk1N2RmZmQ2ODY4OWFiMDVjNTJmYTIwNWQKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9BdHRyL3BhcmVudC1hZG9wdC1ub2Rl Lmh0bWwKQEAgLTAsMCArMSwxOCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgor PHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+ Cis8L2hlYWQ+Cis8Ym9keT4KKzxkaXYgaWQ9InRhcmdldCI+PC9kaXY+Cis8c2NyaXB0PgordmFy IHRhcmdldCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0YXJnZXQiKTsKK3ZhciBhdHRyID0g dGFyZ2V0LmF0dHJpYnV0ZXNbMF07Cit2YXIgYW5vdGhlckRvY3VtZW50ID0gZG9jdW1lbnQuaW1w bGVtZW50YXRpb24uY3JlYXRlRG9jdW1lbnQoImh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwi LCAiIiwgbnVsbCk7Cithbm90aGVyRG9jdW1lbnQudGl0bGUgPSAiSGVsbG8iOworYW5vdGhlckRv Y3VtZW50LmFkb3B0Tm9kZSh0YXJnZXQpOworc2hvdWxkQmUoImF0dHIub3duZXJEb2N1bWVudC50 aXRsZSIsICJhbm90aGVyRG9jdW1lbnQudGl0bGUiKTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9 Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5Pgor PC9odG1sPgo=