139557 2014-12-11 12:57:16 -0800 Addressing post-review comments in r177035 2014-12-17 14:29:30 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 mmaxfield mmaxfield darin dino jonlee simon.fraser thorton zalan oldest_to_newest 1054594 0 mmaxfield 2014-12-11 12:57:16 -0800 Addressing post-review comments in r177035 1054599 1 243141 mmaxfield 2014-12-11 13:11:42 -0800 Created attachment 243141 Patch 1054848 2 243141 darin 2014-12-12 10:12:03 -0800 Comment on attachment 243141 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=243141&action=review I like the direction here, but we need a little more attention to various details, I think, to get the full benefit here. Some call sites are using an empty rectangle when there is no rectangle where instead they should be doing nothing at all in that case. Other call sites are not updating layout but it’s often wrong to get a renderer without doing that first. And all the call sites are using RenderObject* but I think that’s often not a specific-enough type. > Source/WebCore/accessibility/AccessibilitySlider.cpp:162 > + if (RenderObject* thumbRenderer = downcast<HTMLInputElement>(sliderRenderer->node())->sliderThumbElement()->renderer()) I don’t think an HTMLInputElement’s renderer is a RenderObject. I think it’s a more specific class, probably RenderElement. I suggest using auto* or RenderElement* instead of explicitly widening the type to RenderObject. Same might apply to the m_parent->renderer result above, or maybe not. But also, it’s kind of weak to check that the renderer is a RenderSlider and then not cast to that type before getting the element. Generally once we do a type check we want to use the narrower type because we might get more efficient code, even if not now, in the future. > Source/WebCore/html/ColorInputType.cpp:209 > + if (RenderObject* renderer = element().renderer()) > + element().document().view()->contentsToRootView(renderer->absoluteBoundingBoxRect()); > + return IntRect(); Same comment. Not sure RenderObject is the correct type here. I’m also not sure why it’s right for this to call renderer() without updating layout first. Finally, I think early return reads better even though we lose the opportunity to narrowly scope the local variable by defining it in the if condition. > Source/WebCore/html/HTMLInputElement.cpp:1880 > + if (RenderObject* renderer = this->renderer()) Again. > Source/WebCore/html/ValidationMessage.cpp:182 > + if (RenderObject* renderer = m_element->renderer()) Again. > Source/WebCore/html/ValidationMessage.cpp:184 > + adjustBubblePosition(boundingBox, m_bubble.get()); I think it’s strange to pass an empty rectangle in when there’s no renderer. We should think about whether that’s actually helpful. Maybe we should be skipping more code rather than just using an empty rectangle. Probably applies to many more of the call sites, not just this one. 1055698 3 243141 mmaxfield 2014-12-15 12:14:19 -0800 Comment on attachment 243141 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=243141&action=review >> Source/WebCore/accessibility/AccessibilitySlider.cpp:162 >> + if (RenderObject* thumbRenderer = downcast<HTMLInputElement>(sliderRenderer->node())->sliderThumbElement()->renderer()) > > I don’t think an HTMLInputElement’s renderer is a RenderObject. I think it’s a more specific class, probably RenderElement. I suggest using auto* or RenderElement* instead of explicitly widening the type to RenderObject. Same might apply to the m_parent->renderer result above, or maybe not. But also, it’s kind of weak to check that the renderer is a RenderSlider and then not cast to that type before getting the element. Generally once we do a type check we want to use the narrower type because we might get more efficient code, even if not now, in the future. Done. m_parent is an AccessibilityObject, which means that renderer() returns a RenderObject. I think you're right about downcasting the RenderSlider, but in this case, I'm not sure it actually makes sense. Here, we are only getting the renderer so that we can get the node from it, and RenderSlider::node() doesn't have any overrides of RenderObject::node(). If we downcasted to a RenderSlider, it would look like downcast<HTMLInputElement>(downcast<RenderSlider>(sliderRenderer).node()) which seems too verbose for not really any gain. >> Source/WebCore/html/ColorInputType.cpp:209 >> + return IntRect(); > > Same comment. Not sure RenderObject is the correct type here. > > I’m also not sure why it’s right for this to call renderer() without updating layout first. Finally, I think early return reads better even though we lose the opportunity to narrowly scope the local variable by defining it in the if condition. Done. I'm not sure either. I've updated https://bugs.webkit.org/show_bug.cgi?id=139512 to include this bit of research. >> Source/WebCore/html/HTMLInputElement.cpp:1880 >> + if (RenderObject* renderer = this->renderer()) > > Again. This call actually returns a RenderObject. >> Source/WebCore/html/ValidationMessage.cpp:182 >> + if (RenderObject* renderer = m_element->renderer()) > > Again. Done. >> Source/WebCore/html/ValidationMessage.cpp:184 >> + adjustBubblePosition(boundingBox, m_bubble.get()); > > I think it’s strange to pass an empty rectangle in when there’s no renderer. We should think about whether that’s actually helpful. Maybe we should be skipping more code rather than just using an empty rectangle. Probably applies to many more of the call sites, not just this one. Yeah, you're right. Done. 1055699 4 mmaxfield 2014-12-15 12:24:20 -0800 Committed r177301: <http://trac.webkit.org/changeset/177301> 1055988 5 243141 darin 2014-12-16 09:30:25 -0800 Comment on attachment 243141 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=243141&action=review >>> Source/WebCore/accessibility/AccessibilitySlider.cpp:162 >>> + if (RenderObject* thumbRenderer = downcast<HTMLInputElement>(sliderRenderer->node())->sliderThumbElement()->renderer()) >> >> I don’t think an HTMLInputElement’s renderer is a RenderObject. I think it’s a more specific class, probably RenderElement. I suggest using auto* or RenderElement* instead of explicitly widening the type to RenderObject. Same might apply to the m_parent->renderer result above, or maybe not. But also, it’s kind of weak to check that the renderer is a RenderSlider and then not cast to that type before getting the element. Generally once we do a type check we want to use the narrower type because we might get more efficient code, even if not now, in the future. > > Done. > > m_parent is an AccessibilityObject, which means that renderer() returns a RenderObject. > > I think you're right about downcasting the RenderSlider, but in this case, I'm not sure it actually makes sense. Here, we are only getting the renderer so that we can get the node from it, and RenderSlider::node() doesn't have any overrides of RenderObject::node(). If we downcasted to a RenderSlider, it would look like downcast<HTMLInputElement>(downcast<RenderSlider>(sliderRenderer).node()) which seems too verbose for not really any gain. No, you got this wrong. It’s *wrong* for this code to hardcode the knowledge that the node() of a RenderSlider is an HTMLInputElement. That assumption is simply incorrect to include in the accessibility code. It needs to be in RenderSlider’s own code. And contrary to what you say, everything needed is in place. There is a function named RenderSlider::element, which returns an HTMLInputElement&. That is definitely what you should be using instead of calling RenderObject::node() and then casting to HTMLInputElement*. You say that RenderSlider::node doesn’t have overrides of RenderObject::node, but you’re missing the fact that RenderElement, a class in the RenderSlider hierarchy, completely deletes the RenderObject::node() function so you can’t call it without casting to RenderObject. The code should look like this: if (auto* thumbRenderer = downcast<RenderSlider>(*sliderRenderer).element().renderer()) Or if you prefer to use RenderElement* instead of auto, that would be OK. >>> Source/WebCore/html/HTMLInputElement.cpp:1880 >>> + if (RenderObject* renderer = this->renderer()) >> >> Again. > > This call actually returns a RenderObject. No. HTMLInputElement has ContainerNode in its inheritance hierarchy. ContainerNode::renderer returns a RenderElement*. 1056271 6 243141 mmaxfield 2014-12-16 22:42:50 -0800 Comment on attachment 243141 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=243141&action=review Because these changes are trivial, I'll manually commit them tomorrow (It's too late tonight). >>>> Source/WebCore/accessibility/AccessibilitySlider.cpp:162 >>>> + if (RenderObject* thumbRenderer = downcast<HTMLInputElement>(sliderRenderer->node())->sliderThumbElement()->renderer()) >>> >>> I don’t think an HTMLInputElement’s renderer is a RenderObject. I think it’s a more specific class, probably RenderElement. I suggest using auto* or RenderElement* instead of explicitly widening the type to RenderObject. Same might apply to the m_parent->renderer result above, or maybe not. But also, it’s kind of weak to check that the renderer is a RenderSlider and then not cast to that type before getting the element. Generally once we do a type check we want to use the narrower type because we might get more efficient code, even if not now, in the future. >> >> Done. >> >> m_parent is an AccessibilityObject, which means that renderer() returns a RenderObject. >> >> I think you're right about downcasting the RenderSlider, but in this case, I'm not sure it actually makes sense. Here, we are only getting the renderer so that we can get the node from it, and RenderSlider::node() doesn't have any overrides of RenderObject::node(). If we downcasted to a RenderSlider, it would look like downcast<HTMLInputElement>(downcast<RenderSlider>(sliderRenderer).node()) which seems too verbose for not really any gain. > > No, you got this wrong. It’s *wrong* for this code to hardcode the knowledge that the node() of a RenderSlider is an HTMLInputElement. That assumption is simply incorrect to include in the accessibility code. It needs to be in RenderSlider’s own code. And contrary to what you say, everything needed is in place. > > There is a function named RenderSlider::element, which returns an HTMLInputElement&. That is definitely what you should be using instead of calling RenderObject::node() and then casting to HTMLInputElement*. You say that RenderSlider::node doesn’t have overrides of RenderObject::node, but you’re missing the fact that RenderElement, a class in the RenderSlider hierarchy, completely deletes the RenderObject::node() function so you can’t call it without casting to RenderObject. The code should look like this: > > if (auto* thumbRenderer = downcast<RenderSlider>(*sliderRenderer).element().renderer()) > > Or if you prefer to use RenderElement* instead of auto, that would be OK. I see, that makes sense. Thanks for the explanation. Done. >>>> Source/WebCore/html/HTMLInputElement.cpp:1880 >>>> + if (RenderObject* renderer = this->renderer()) >>> >>> Again. >> >> This call actually returns a RenderObject. > > No. > > HTMLInputElement has ContainerNode in its inheritance hierarchy. ContainerNode::renderer returns a RenderElement*. You're right; this is a case of trusting Xcode's index over actually checking. I command-clicked on renderer() and it took me to AccessibilityRenderObject::renderer() and I only looked at its return type. :-| Done. 1056272 7 darin 2014-12-16 22:44:39 -0800 (In reply to comment #6) > Because these changes are trivial, I'll manually commit them tomorrow (It's > too late tonight). No rush. Just wanted to get this as clean as possible while we are modifying the code. 1056330 8 mmaxfield 2014-12-17 08:34:57 -0800 (In reply to comment #7) > (In reply to comment #6) > > Because these changes are trivial, I'll manually commit them tomorrow (It's > > too late tonight). > > No rush. Just wanted to get this as clean as possible while we are modifying > the code. Committed in r177444 1056335 9 darin 2014-12-17 08:46:46 -0800 Oops, you checked in my bad code! I wrote this: if (auto* thumbRenderer = downcast<RenderSlider>(*sliderRenderer).element().renderer()) return thumbRenderer->absoluteBoundingBoxRect(); But it needs to be this: if (auto* thumbRenderer = downcast<RenderSlider>(*sliderRenderer).element().sliderThumbElement()->renderer()) return thumbRenderer->absoluteBoundingBoxRect(); 1056556 10 mmaxfield 2014-12-17 14:29:30 -0800 Yeah, the testers realized this mistake and I already fixed it. r177449 243141 2014-12-11 13:11:42 -0800 2014-12-12 10:12:03 -0800 Patch bug-139557-20141211131225.patch text/plain 16115 mmaxfield U3VidmVyc2lvbiBSZXZpc2lvbjogMTc3MDk5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDk2NGFjNWI0MTk0NDA4 ZDM2YWEzZGUyN2FkNTBhNmJjNTA3YmYxYy4uMDU0NzUzN2E1NGY0M2ZhZjA5MzMwYjFmODJhOTgx MmFkODk0ZGM3OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM5IEBACisyMDE0LTEyLTExICBNeWxl cyBDLiBNYXhmaWVsZCAgPG1tYXhmaWVsZEBhcHBsZS5jb20+CisKKyAgICAgICAgQWRkcmVzc2lu ZyBwb3N0LXJldmlldyBjb21tZW50cyBpbiByMTc3MDM1CisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzk1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUaGlzIHBhdGNoIGRlbGV0ZXMgdGhlIGhlbHBlciBm dW5jdGlvbnMgcmVuZGVyZXJCb3VuZGluZ0JveCgpIGFuZCByZW5kZXJlckFuY2hvclJlY3QoKSBh bmQKKyAgICAgICAgbWlncmF0ZXMgY2FsbGVycyB0byB1c2luZyByZW5kZXJlcnMgZGlyZWN0bHku CisKKyAgICAgICAgSXQgYWxzbyBpbXByb3ZlcyB0aGUgY29tbWVudCBpbiBSZW5kZXJFbGVtZW50 LmggcmVnYXJkaW5nIFJlbmRlckVsZW1lbnQ6OmFuY2hvclJlY3QoKS4KKworICAgICAgICBObyBu ZXcgdGVzdHMgYmVjYXVzZSB0aGlzIGlzIHNpbXBseSByZWZhY3RvcmluZy4KKworICAgICAgICAq IFdlYkNvcmUuZXhwLmluOiBEZWxldGUgZXhwb3J0ZWQgc3ltYm9sIGZvciByZW5kZXJlckJvdW5k aW5nQm94KCkKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlTbGlkZXIuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVNsaWRlclRodW1iOjplbGVtZW50UmVj dCk6IE1pZ3JhdGUgb2ZmIHJlbmRlcmVyQm91bmRpbmdCb3goKQorICAgICAgICAqIGRvbS9Db250 YWluZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnJlbmRlcmVyQW5jaG9yUmVjdCk6IERl bGV0ZWQuCisgICAgICAgICogZG9tL0NvbnRhaW5lck5vZGUuaDoKKyAgICAgICAgKiBkb20vTm9k ZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpyZW5kZXJlckJvdW5kaW5nQm94KTogRGVsZXRlZC4K KyAgICAgICAgKiBkb20vTm9kZS5oOgorICAgICAgICAqIGh0bWwvQ29sb3JJbnB1dFR5cGUuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6Q29sb3JJbnB1dFR5cGU6OmVsZW1lbnRSZWN0UmVsYXRpdmVU b1Jvb3RWaWV3KTogTWlncmF0ZSBvZmYgcmVuZGVyZXJCb3VuZGluZ0JveCgpLgorICAgICAgICAq IGh0bWwvSFRNTElucHV0RWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MSW5wdXRF bGVtZW50OjpzZXR1cERhdGVUaW1lQ2hvb3NlclBhcmFtZXRlcnMpOiBEaXR0by4KKyAgICAgICAg KiBodG1sL1ZhbGlkYXRpb25NZXNzYWdlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlZhbGlkYXRp b25NZXNzYWdlOjpidWlsZEJ1YmJsZVRyZWUpOiBEaXR0by4KKyAgICAgICAgKiBwYWdlL0ZyYW1l Vmlldy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZVZpZXc6OnNjcm9sbEVsZW1lbnRUb1Jl Y3QpOiBNaWdyYXRlIG9mZiByZW5kZXJlckFuY2hvclJlY3QoKS4KKyAgICAgICAgKFdlYkNvcmU6 OkZyYW1lVmlldzo6c2Nyb2xsVG9BbmNob3IpOiBEaXR0by4KKyAgICAgICAgKiBwYWdlL1NwYXRp YWxOYXZpZ2F0aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Om5vZGVSZWN0SW5BYnNvbHV0ZUNv b3JkaW5hdGVzKTogTWlncmF0ZSBvZmYgcmVuZGVyZXJCb3VuZGluZ0JveCgpLgorICAgICAgICAq IHJlbmRlcmluZy9SZW5kZXJFbGVtZW50Lmg6CisKIDIwMTQtMTItMTAgIFJvZ2VyIEZvbmcgIDxy b2dlcl9mb25nQGFwcGxlLmNvbT4KIAogICAgICAgICBJbXBsZW1lbnQgTXVsdGlwbGUgUmVuZGVy IFRhcmdldHMgYXMgV2ViR0wgMSBleHRlbnNpb24uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L21hYy9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cKaW5kZXggYTdhMWZi NDc5ODNkYzZkNDRhMjQ4YWUzMDA0ZjA1OTc3NDY3MmYwNC4uOGIyZDBhYzQxMzhlYWVmYmMwNTQ5 OTllMDQwOTQzZGY2YTFlNTE4OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisy MDE0LTEyLTExICBNeWxlcyBDLiBNYXhmaWVsZCAgPG1tYXhmaWVsZEBhcHBsZS5jb20+CisKKyAg ICAgICAgQWRkcmVzc2luZyBwb3N0LXJldmlldyBjb21tZW50cyBpbiByMTc3MDM1CisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzk1NTcKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYlZpZXcvV2ViQWN0 aW9uTWVudUNvbnRyb2xsZXIubW06CisgICAgICAgIChlbGVtZW50Qm91bmRpbmdCb3hJbldpbmRv d0Nvb3JkaW5hdGVzRnJvbU5vZGUpOiBNaWdyYXRlIG9mZiByZW5kZXJlckJvdW5kaW5nQm94KCku CisKIDIwMTQtMTItMTAgIEFuZGVycyBDYXJsc3NvbiAgPGFuZGVyc2NhQGFwcGxlLmNvbT4KIAog ICAgICAgICBBZGQgV2ViU3RvcmFnZU5hbWVzcGFjZVByb3ZpZGVyOjpjbG9zZUxvY2FsU3RvcmFn ZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIv Q2hhbmdlTG9nCmluZGV4IGM5YjkxNTQ3YWJkMTgwZDI4Yzk5OThmMDg5ZDRkODMyYjVjNzcyM2Yu LjdhMDNjMTM3YmEyZDE0MDMyZTE3ZjNiZjg4YTYxZThiZmUyZjc0ZDIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxNSBAQAorMjAxNC0xMi0xMSAgTXlsZXMgQy4gTWF4ZmllbGQgIDxtbWF4ZmllbGRA YXBwbGUuY29tPgorCisgICAgICAgIEFkZHJlc3NpbmcgcG9zdC1yZXZpZXcgY29tbWVudHMgaW4g cjE3NzAzNQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MTM5NTU3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg KiBTaGFyZWQvV2ViSGl0VGVzdFJlc3VsdC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYkhpdFRl c3RSZXN1bHQ6OkRhdGE6OmVsZW1lbnRCb3VuZGluZ0JveEluV2luZG93Q29vcmRpbmF0ZXMpOiBN aWdyYXRlIG9mZiByZW5kZXJlckJvdW5kaW5nQm94KCkuCisgICAgICAgICogV2ViUHJvY2Vzcy9X ZWJQYWdlL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViUGFnZUNvb3JkaW5hdGVkR3JhcGhpY3MuY3Bw OgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlOjpmaW5kWm9vbWFibGVBcmVhRm9yUG9pbnQpOiBE aXR0by4KKwogMjAxNC0xMi0xMCAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29t PgogCiAgICAgICAgIEJlZ2luIGZpeGluZyB0cmFuc2llbnQgbG9jYWwgc3RvcmFnZSBoYW5kbGlu ZwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4gYi9Tb3VyY2UvV2Vi Q29yZS9XZWJDb3JlLmV4cC5pbgppbmRleCBlNzUwYTIzODFkYTQ0YTA1NzA4NjJiYWI1MWJhOTVm MzYxODE3OTQ3Li5iNGM5NTE4NDE2MGYzODcxYzgwODFlMWE0MWRmZmVmMmI2NWMyMjAzIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgorKysgYi9Tb3VyY2UvV2ViQ29y ZS9XZWJDb3JlLmV4cC5pbgpAQCAtODY5LDcgKzg2OSw2IEBAIF9fWk43V2ViQ29yZTE5VGV4dFJl c291cmNlRGVjb2RlckQxRXYKIF9fWk43V2ViQ29yZTE5ZW5jbG9zaW5nTGF5b3V0UmVjdEVSS05T XzlGbG9hdFJlY3RFCiBfX1pON1dlYkNvcmUxOWZsb2F0VmFsdWVGb3JMZW5ndGhFUktOU182TGVu Z3RoRWYKIF9fWk43V2ViQ29yZTE5Z2V0RmlsZUNyZWF0aW9uVGltZUVSS04zV1RGNlN0cmluZ0VS bAotX19aTjdXZWJDb3JlMTlyZW5kZXJlckJvdW5kaW5nQm94RVJLTlNfNE5vZGVFCiBfX1pON1dl YkNvcmUxOXRvSW50MzJFbmZvcmNlUmFuZ2VFUE4zSlNDOUV4ZWNTdGF0ZUVOUzBfN0pTVmFsdWVF CiBfX1pON1dlYkNvcmUyMEFwcGxpY2F0aW9uQ2FjaGVIb3N0MTdtYXliZUxvYWRSZXNvdXJjZUVQ TlNfMTRSZXNvdXJjZUxvYWRlckVSS05TXzE1UmVzb3VyY2VSZXF1ZXN0RVJLTlNfM1VSTEUKIF9f Wk43V2ViQ29yZTIwQXBwbGljYXRpb25DYWNoZUhvc3QyNW1heWJlTG9hZEZhbGxiYWNrRm9yRXJy b3JFUE5TXzE0UmVzb3VyY2VMb2FkZXJFUktOU18xM1Jlc291cmNlRXJyb3JFCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlTbGlkZXIuY3BwIGIv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5U2xpZGVyLmNwcAppbmRl eCA0ZDIzNWE5YTA1MmYzYTJmNzY1NmFkYjYyMDIwNjMyMTc0NWQ3NjczLi5jMDA5NDMzNGQ3OTMz YmNjZWUwYWVmYTBmMTNjYzM2ZTNmMzg1MDhlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlTbGlkZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVNsaWRlci5jcHAKQEAgLTE1OSw3ICsxNTksOSBA QCBMYXlvdXRSZWN0IEFjY2Vzc2liaWxpdHlTbGlkZXJUaHVtYjo6ZWxlbWVudFJlY3QoKSBjb25z dAogICAgIFJlbmRlck9iamVjdCogc2xpZGVyUmVuZGVyZXIgPSBtX3BhcmVudC0+cmVuZGVyZXIo KTsKICAgICBpZiAoIXNsaWRlclJlbmRlcmVyIHx8ICFzbGlkZXJSZW5kZXJlci0+aXNTbGlkZXIo KSkKICAgICAgICAgcmV0dXJuIExheW91dFJlY3QoKTsKLSAgICByZXR1cm4gcmVuZGVyZXJCb3Vu ZGluZ0JveCgqZG93bmNhc3Q8SFRNTElucHV0RWxlbWVudD4oc2xpZGVyUmVuZGVyZXItPm5vZGUo KSktPnNsaWRlclRodW1iRWxlbWVudCgpKTsKKyAgICBpZiAoUmVuZGVyT2JqZWN0KiB0aHVtYlJl bmRlcmVyID0gZG93bmNhc3Q8SFRNTElucHV0RWxlbWVudD4oc2xpZGVyUmVuZGVyZXItPm5vZGUo KSktPnNsaWRlclRodW1iRWxlbWVudCgpLT5yZW5kZXJlcigpKQorICAgICAgICByZXR1cm4gdGh1 bWJSZW5kZXJlci0+YWJzb2x1dGVCb3VuZGluZ0JveFJlY3QoKTsKKyAgICByZXR1cm4gTGF5b3V0 UmVjdCgpOwogfQogCiBib29sIEFjY2Vzc2liaWxpdHlTbGlkZXJUaHVtYjo6Y29tcHV0ZUFjY2Vz c2liaWxpdHlJc0lnbm9yZWQoKSBjb25zdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9t L0NvbnRhaW5lck5vZGUuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL0NvbnRhaW5lck5vZGUuY3Bw CmluZGV4IGFiNGIxYTM0NTRlMGJkZTAwNDkzODI2YmNlZjUzYjY2MjhlMmY2ZmYuLjk2MDk2MDc0 MmI1ZjI0ZGQyZDc5ZmRhMTM5NmZiZWU1OTJmZTcxNDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2RvbS9Db250YWluZXJOb2RlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vQ29udGFp bmVyTm9kZS5jcHAKQEAgLTkxMCwxMSArOTEwLDQgQEAgUmVmUHRyPFJhZGlvTm9kZUxpc3Q+IENv bnRhaW5lck5vZGU6OnJhZGlvTm9kZUxpc3QoY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lKQogICAg IHJldHVybiBlbnN1cmVSYXJlRGF0YSgpLmVuc3VyZU5vZGVMaXN0cygpLmFkZENhY2hlV2l0aEF0 b21pY05hbWU8UmFkaW9Ob2RlTGlzdD4oKnRoaXMsIG5hbWUpOwogfQogCi1MYXlvdXRSZWN0IHJl bmRlcmVyQW5jaG9yUmVjdChjb25zdCBDb250YWluZXJOb2RlJiBub2RlKQotewotICAgIGlmIChS ZW5kZXJFbGVtZW50KiByZW5kZXJlciA9IG5vZGUucmVuZGVyZXIoKSkKLSAgICAgICAgcmV0dXJu IHJlbmRlcmVyLT5hbmNob3JSZWN0KCk7Ci0gICAgcmV0dXJuIExheW91dFJlY3QoKTsKLX0KLQog fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0Nv bnRhaW5lck5vZGUuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Db250YWluZXJOb2RlLmgKaW5kZXgg OTQ0YzMzZDgwNWZmNDNiOTJhMzE2NTk2NTEwNjBhODRlYjNkMTc3My4uZjE4NTVjOGFjMjBhM2Nj Mjc5YTFkZjhhMzBlYTMzOWVhZmI3OGNhOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9t L0NvbnRhaW5lck5vZGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vQ29udGFpbmVyTm9kZS5o CkBAIC0zMDQsOCArMzA0LDYgQEAgcHJpdmF0ZToKICAgICBDaGlsZE5vZGVzTGF6eVNuYXBzaG90 KiBtX25leHRTbmFwc2hvdDsKIH07CiAKLUxheW91dFJlY3QgcmVuZGVyZXJBbmNob3JSZWN0KGNv bnN0IENvbnRhaW5lck5vZGUmKTsKLQogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiBTUEVDSUFM SVpFX1RZUEVfVFJBSVRTX0JFR0lOKFdlYkNvcmU6OkNvbnRhaW5lck5vZGUpCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9kb20vTm9kZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vTm9kZS5j cHAKaW5kZXggM2UxOTljMDgwM2Q5ZjZmYTFhZjNmY2IwNjM5MzViOTVlOGYzNjE2MS4uNTI0NzJl MzFmZjZjMjkwMzY4N2VjNTE3ODJjMTQxODVhOTYxNjU5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvZG9tL05vZGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Ob2RlLmNwcApAQCAt MjI1OSwxMyArMjI1OSw2IEBAIGJvb2wgTm9kZTo6aW5SZW5kZXJlZERvY3VtZW50KCkgY29uc3QK ICAgICByZXR1cm4gaW5Eb2N1bWVudCgpICYmIGRvY3VtZW50KCkuaGFzTGl2aW5nUmVuZGVyVHJl ZSgpOwogfQogCi1JbnRSZWN0IHJlbmRlcmVyQm91bmRpbmdCb3goY29uc3QgTm9kZSYgbm9kZSkK LXsKLSAgICBpZiAoUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IG5vZGUucmVuZGVyZXIoKSkKLSAg ICAgICAgcmV0dXJuIHJlbmRlcmVyLT5hYnNvbHV0ZUJvdW5kaW5nQm94UmVjdCgpOwotICAgIHJl dHVybiBJbnRSZWN0KCk7Ci19Ci0KIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2lmbmRlZiBO REVCVUcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Ob2RlLmggYi9Tb3VyY2UvV2Vi Q29yZS9kb20vTm9kZS5oCmluZGV4IGFjMWVjZjRlMTJlM2EzMDg3ZDUxNTA2NDlmMzhkMzgxMWQy MTZmYTMuLmI3NGQxNGE3ZjY3YzE3OTk0MDExYzdlMjY1OGIyMWZkODlmZWVlZTEgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Ob2RlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL05v ZGUuaApAQCAtNzM3LDggKzczNyw2IEBAIGlubGluZSBDb250YWluZXJOb2RlKiBOb2RlOjpwYXJl bnROb2RlR3VhcmFudGVlZEhvc3RGcmVlKCkgY29uc3QKICAgICByZXR1cm4gcGFyZW50Tm9kZSgp OwogfQogCi1XRUJDT1JFX0VYUE9SVCBJbnRSZWN0IHJlbmRlcmVyQm91bmRpbmdCb3goY29uc3Qg Tm9kZSYpOwotCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNpZm5kZWYgTkRFQlVHCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0NvbG9ySW5wdXRUeXBlLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL2h0bWwvQ29sb3JJbnB1dFR5cGUuY3BwCmluZGV4IGU2Y2YwNTIwODI4OWNkMDYyZmQx NzgwOGY3ODgwZTEzY2ZhZDM2M2YuLmIxYTcxOGFlMTI5Y2IzNDNjODliZDNlZjdjZTAzOGE5Zjlm OThiY2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvQ29sb3JJbnB1dFR5cGUuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvQ29sb3JJbnB1dFR5cGUuY3BwCkBAIC0yMDQsNyAr MjA0LDkgQEAgSFRNTEVsZW1lbnQqIENvbG9ySW5wdXRUeXBlOjpzaGFkb3dDb2xvclN3YXRjaCgp IGNvbnN0CiAKIEludFJlY3QgQ29sb3JJbnB1dFR5cGU6OmVsZW1lbnRSZWN0UmVsYXRpdmVUb1Jv b3RWaWV3KCkgY29uc3QKIHsKLSAgICByZXR1cm4gZWxlbWVudCgpLmRvY3VtZW50KCkudmlldygp LT5jb250ZW50c1RvUm9vdFZpZXcocmVuZGVyZXJCb3VuZGluZ0JveChlbGVtZW50KCkpKTsKKyAg ICBpZiAoUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGVsZW1lbnQoKS5yZW5kZXJlcigpKQorICAg ICAgICBlbGVtZW50KCkuZG9jdW1lbnQoKS52aWV3KCktPmNvbnRlbnRzVG9Sb290VmlldyhyZW5k ZXJlci0+YWJzb2x1dGVCb3VuZGluZ0JveFJlY3QoKSk7CisgICAgcmV0dXJuIEludFJlY3QoKTsK IH0KIAogQ29sb3IgQ29sb3JJbnB1dFR5cGU6OmN1cnJlbnRDb2xvcigpCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAppbmRleCBjMmZlYWU3Nzg5YWY4ZTlmOGRiOTlmMGZi Y2MyYzU5NTRmMGM2MTU3Li43ZDNiZjFlYWFiZjlkNThjNGRiNzc0ZTQ5MGZiYzQ1OWQ0OWYwNzg2 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKQEAgLTE4NzcsNyAr MTg3NywxMCBAQCBib29sIEhUTUxJbnB1dEVsZW1lbnQ6OnNldHVwRGF0ZVRpbWVDaG9vc2VyUGFy YW1ldGVycyhEYXRlVGltZUNob29zZXJQYXJhbWV0ZXJzJgogICAgICAgICBwYXJhbWV0ZXJzLnN0 ZXBCYXNlID0gMDsKICAgICB9CiAKLSAgICBwYXJhbWV0ZXJzLmFuY2hvclJlY3RJblJvb3RWaWV3 ID0gZG9jdW1lbnQoKS52aWV3KCktPmNvbnRlbnRzVG9Sb290VmlldyhyZW5kZXJlckJvdW5kaW5n Qm94KCp0aGlzKSk7CisgICAgaWYgKFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSB0aGlzLT5yZW5k ZXJlcigpKQorICAgICAgICBwYXJhbWV0ZXJzLmFuY2hvclJlY3RJblJvb3RWaWV3ID0gZG9jdW1l bnQoKS52aWV3KCktPmNvbnRlbnRzVG9Sb290VmlldyhyZW5kZXJlci0+YWJzb2x1dGVCb3VuZGlu Z0JveFJlY3QoKSk7CisgICAgZWxzZQorICAgICAgICBwYXJhbWV0ZXJzLmFuY2hvclJlY3RJblJv b3RWaWV3ID0gSW50UmVjdCgpOwogICAgIHBhcmFtZXRlcnMuY3VycmVudFZhbHVlID0gdmFsdWUo KTsKICAgICBwYXJhbWV0ZXJzLmlzQW5jaG9yRWxlbWVudFJUTCA9IGNvbXB1dGVkU3R5bGUoKS0+ ZGlyZWN0aW9uKCkgPT0gUlRMOwogI2lmIEVOQUJMRShEQVRBTElTVF9FTEVNRU5UKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9WYWxpZGF0aW9uTWVzc2FnZS5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL1ZhbGlkYXRpb25NZXNzYWdlLmNwcAppbmRleCBjYjRlNzExODk3ODAyOWMw ZWI4NGU0NDAyYzEyZjM1YjQ0NWM0NGM5Li42ODE4MDA2NzA5M2I1YmJmMTFhNjlmMTUwOGM2NjFl OGE5OGUyZmQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1ZhbGlkYXRpb25NZXNz YWdlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1ZhbGlkYXRpb25NZXNzYWdlLmNwcApA QCAtMTc4LDcgKzE3OCwxMCBAQCB2b2lkIFZhbGlkYXRpb25NZXNzYWdlOjpidWlsZEJ1YmJsZVRy ZWUoKQogICAgIG1fYnViYmxlLT5zZXRJbmxpbmVTdHlsZVByb3BlcnR5KENTU1Byb3BlcnR5UG9z aXRpb24sIENTU1ZhbHVlQWJzb2x1dGUpOwogICAgIHNoYWRvd1Jvb3QuYXBwZW5kQ2hpbGQobV9i dWJibGUuZ2V0KCksIEFTU0VSVF9OT19FWENFUFRJT04pOwogICAgIGRvY3VtZW50LnVwZGF0ZUxh eW91dCgpOwotICAgIGFkanVzdEJ1YmJsZVBvc2l0aW9uKHJlbmRlcmVyQm91bmRpbmdCb3goKm1f ZWxlbWVudCksIG1fYnViYmxlLmdldCgpKTsKKyAgICBMYXlvdXRSZWN0IGJvdW5kaW5nQm94Owor ICAgIGlmIChSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gbV9lbGVtZW50LT5yZW5kZXJlcigpKQor ICAgICAgICBib3VuZGluZ0JveCA9IHJlbmRlcmVyLT5hYnNvbHV0ZUJvdW5kaW5nQm94UmVjdCgp OworICAgIGFkanVzdEJ1YmJsZVBvc2l0aW9uKGJvdW5kaW5nQm94LCBtX2J1YmJsZS5nZXQoKSk7 CiAKICAgICBSZWZQdHI8SFRNTERpdkVsZW1lbnQ+IGNsaXBwZXIgPSBIVE1MRGl2RWxlbWVudDo6 Y3JlYXRlKGRvY3VtZW50KTsKICAgICBjbGlwcGVyLT5zZXRQc2V1ZG8oQXRvbWljU3RyaW5nKCIt d2Via2l0LXZhbGlkYXRpb24tYnViYmxlLWFycm93LWNsaXBwZXIiLCBBdG9taWNTdHJpbmc6OkNv bnN0cnVjdEZyb21MaXRlcmFsKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0Zy YW1lVmlldy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKaW5kZXggOWNh MWZmMmViM2Y5ZGJjMjQwNTYzOGE5ZTU2MDFkNjhiNDBlMzczZS4uMWE4MTcxOGYzMTg1ZmU0NWZm OGI4YjFhNTBjNjUxNTdkZWMxMTU1NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9G cmFtZVZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcApAQCAt MjAxNyw3ICsyMDE3LDkgQEAgdm9pZCBGcmFtZVZpZXc6OnNjcm9sbEVsZW1lbnRUb1JlY3QoRWxl bWVudCogZWxlbWVudCwgY29uc3QgSW50UmVjdCYgcmVjdCkKIHsKICAgICBmcmFtZSgpLmRvY3Vt ZW50KCktPnVwZGF0ZUxheW91dElnbm9yZVBlbmRpbmdTdHlsZXNoZWV0cygpOwogCi0gICAgTGF5 b3V0UmVjdCBib3VuZHMgPSByZW5kZXJlckFuY2hvclJlY3QoKmVsZW1lbnQpOworICAgIExheW91 dFJlY3QgYm91bmRzOworICAgIGlmIChSZW5kZXJFbGVtZW50KiByZW5kZXJlciA9IGVsZW1lbnQt PnJlbmRlcmVyKCkpCisgICAgICAgIGJvdW5kcyA9IHJlbmRlcmVyLT5hbmNob3JSZWN0KCk7CiAg ICAgaW50IGNlbnRlcmluZ09mZnNldFggPSAocmVjdC53aWR0aCgpIC0gYm91bmRzLndpZHRoKCkp IC8gMjsKICAgICBpbnQgY2VudGVyaW5nT2Zmc2V0WSA9IChyZWN0LmhlaWdodCgpIC0gYm91bmRz LmhlaWdodCgpKSAvIDI7CiAgICAgc2V0U2Nyb2xsUG9zaXRpb24oSW50UG9pbnQoYm91bmRzLngo KSAtIGNlbnRlcmluZ09mZnNldFggLSByZWN0LngoKSwgYm91bmRzLnkoKSAtIGNlbnRlcmluZ09m ZnNldFkgLSByZWN0LnkoKSkpOwpAQCAtMjc4Niw4ICsyNzg4LDggQEAgdm9pZCBGcmFtZVZpZXc6 OnNjcm9sbFRvQW5jaG9yKCkKICAgICAgICAgcmV0dXJuOwogCiAgICAgTGF5b3V0UmVjdCByZWN0 OwotICAgIGlmIChhbmNob3JOb2RlICE9IGZyYW1lKCkuZG9jdW1lbnQoKSkKLSAgICAgICAgcmVj dCA9IHJlbmRlcmVyQW5jaG9yUmVjdCgqYW5jaG9yTm9kZS5nZXQoKSk7CisgICAgaWYgKGFuY2hv ck5vZGUgIT0gZnJhbWUoKS5kb2N1bWVudCgpICYmIGFuY2hvck5vZGUtPnJlbmRlcmVyKCkpCisg ICAgICAgIHJlY3QgPSBhbmNob3JOb2RlLT5yZW5kZXJlcigpLT5hbmNob3JSZWN0KCk7CiAKICAg ICAvLyBTY3JvbGwgbmVzdGVkIGxheWVycyBhbmQgZnJhbWVzIHRvIHJldmVhbCB0aGUgYW5jaG9y LgogICAgIC8vIEFsaWduIHRvIHRoZSB0b3AgYW5kIHRvIHRoZSBjbG9zZXN0IHNpZGUgKHRoaXMg bWF0Y2hlcyBvdGhlciBicm93c2VycykuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdl L1NwYXRpYWxOYXZpZ2F0aW9uLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU3BhdGlhbE5hdmln YXRpb24uY3BwCmluZGV4IGZkMGY4ZmU2ZmE5OGVhNWM2N2Y1OGU0MTk0YmJiYWU5OWNmNDFmYWMu LmE0ODE3YjU0OWQwZjhhM2EwNDcwYWUwODlkNWI3ZDIxZDdkNTk3MmQgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvU3BhdGlhbE5hdmlnYXRpb24uY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BhZ2UvU3BhdGlhbE5hdmlnYXRpb24uY3BwCkBAIC01MjMsNyArNTIzLDkgQEAgTGF5b3V0 UmVjdCBub2RlUmVjdEluQWJzb2x1dGVDb29yZGluYXRlcyhOb2RlKiBub2RlLCBib29sIGlnbm9y ZUJvcmRlcikKICAgICBpZiAoaXM8RG9jdW1lbnQ+KCpub2RlKSkKICAgICAgICAgcmV0dXJuIGZy YW1lUmVjdEluQWJzb2x1dGVDb29yZGluYXRlcyhkb3duY2FzdDxEb2N1bWVudD4oKm5vZGUpLmZy YW1lKCkpOwogCi0gICAgTGF5b3V0UmVjdCByZWN0ID0gcmVjdFRvQWJzb2x1dGVDb29yZGluYXRl cyhub2RlLT5kb2N1bWVudCgpLmZyYW1lKCksIHJlbmRlcmVyQm91bmRpbmdCb3goKm5vZGUpKTsK KyAgICBMYXlvdXRSZWN0IHJlY3Q7CisgICAgaWYgKFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBu b2RlLT5yZW5kZXJlcigpKQorICAgICAgICByZWN0ID0gcmVjdFRvQWJzb2x1dGVDb29yZGluYXRl cyhub2RlLT5kb2N1bWVudCgpLmZyYW1lKCksIHJlbmRlcmVyLT5hYnNvbHV0ZUJvdW5kaW5nQm94 UmVjdCgpKTsKIAogICAgIC8vIEZvciBhdXRob3JzIHRoYXQgdXNlIGJvcmRlciBpbnN0ZWFkIG9m IG91dGxpbmUgaW4gdGhlaXIgQ1NTLCB3ZSBjb21wZW5zYXRlIGJ5IGlnbm9yaW5nIHRoZSBib3Jk ZXIgd2hlbiBjYWxjdWxhdGluZwogICAgIC8vIHRoZSByZWN0IG9mIHRoZSBmb2N1c2VkIGVsZW1l bnQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRWxlbWVudC5o IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckVsZW1lbnQuaAppbmRleCA2NjRhYzNi N2IxODFhYWQwN2E5NmUwYTZkNjllNjAzZTg0NGYwM2FiLi43OTAxYjdhNTM0MThlYmM2M2I0MzNi ZGZhZTU3NTM5NTQ0ODE4MWYxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJFbGVt ZW50LmgKQEAgLTE1MSw3ICsxNTEsOCBAQCBwdWJsaWM6CiAgICAgYm9vbCBoYXNIaWRkZW5CYWNr ZmFjZSgpIGNvbnN0IHsgcmV0dXJuIHN0eWxlKCkuYmFja2ZhY2VWaXNpYmlsaXR5KCkgPT0gQmFj a2ZhY2VWaXNpYmlsaXR5SGlkZGVuOyB9CiAKICAgICAvLyBhbmNob3JSZWN0KCkgaXMgY29uY2Vw dHVhbGx5IHNpbWlsYXIgdG8gYWJzb2x1dGVCb3VuZGluZ0JveFJlY3QoKSwgYnV0IGlzIGludGVu ZGVkIGZvciBzY3JvbGxpbmcgdG8gYW4gYW5jaG9yLgotICAgIC8vIEl0IHdvcmtzIGRpZmZlcmVu dGx5IHRoYW4gYWJzb2x1dGVCb3VuZGluZ0JveFJlY3QoKSBmb3IgaW5saW5lIHJlbmRlcmVycy4K KyAgICAvLyBGb3IgaW5saW5lIHJlbmRlcmVycywgdGhpcyBnZXRzIHRoZSBsb2dpY2FsIHRvcCBs ZWZ0IG9mIHRoZSBmaXJzdCBsZWFmIGNoaWxkIGFuZCB0aGUgbG9naWNhbCBib3R0b20gcmlnaHQg b2YgdGhlCisgICAgLy8gbGFzdCBsZWFmIGNoaWxkLCBjb252ZXJ0cyB0aGVtIHRvIGFic29sdXRl IGNvb3JkaW5hdGVzLCBhbmQgbWFrZXMgYSBib3ggb3V0IG9mIHRoZW0uCiAgICAgTGF5b3V0UmVj dCBhbmNob3JSZWN0KCkgY29uc3Q7CiAKICAgICBib29sIGhhc0ZpbHRlcigpIGNvbnN0IHsgcmV0 dXJuIHN0eWxlKCkuaGFzRmlsdGVyKCk7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFj L1dlYlZpZXcvV2ViQWN0aW9uTWVudUNvbnRyb2xsZXIubW0gYi9Tb3VyY2UvV2ViS2l0L21hYy9X ZWJWaWV3L1dlYkFjdGlvbk1lbnVDb250cm9sbGVyLm1tCmluZGV4IGI4NWFhNzFiNzczODJkNGQx ODY1Y2MyMWY1ZWY1NzdjMjQ2NWM5MzEuLjliZmU1NDQ2MDljNGQwZDRmZWZkMjM4ZjMyZGVjYmYy ZTBhMmZjN2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViQWN0aW9u TWVudUNvbnRyb2xsZXIubW0KKysrIGIvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJBY3Rp b25NZW51Q29udHJvbGxlci5tbQpAQCAtMjYyLDcgKzI2MiwxMSBAQCBzdGF0aWMgSW50UmVjdCBl bGVtZW50Qm91bmRpbmdCb3hJbldpbmRvd0Nvb3JkaW5hdGVzRnJvbU5vZGUoTm9kZSogbm9kZSkK ICAgICBpZiAoIXZpZXcpCiAgICAgICAgIHJldHVybiBJbnRSZWN0KCk7CiAKLSAgICByZXR1cm4g dmlldy0+Y29udGVudHNUb1dpbmRvdyhyZW5kZXJlckJvdW5kaW5nQm94KCpub2RlKSk7CisgICAg UmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IG5vZGUtPnJlbmRlcmVyKCk7CisgICAgaWYgKCFyZW5k ZXJlcikKKyAgICAgICAgcmV0dXJuIEludFJlY3QoKTsKKworICAgIHJldHVybiB2aWV3LT5jb250 ZW50c1RvV2luZG93KHJlbmRlcmVyLT5hYnNvbHV0ZUJvdW5kaW5nQm94UmVjdCgpKTsKIH0KIAog LSAoTlNBcnJheSAqKV9kZWZhdWx0TWVudUl0ZW1zRm9yTGluawpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvU2hhcmVkL1dlYkhpdFRlc3RSZXN1bHQuY3BwIGIvU291cmNlL1dlYktpdDIvU2hh cmVkL1dlYkhpdFRlc3RSZXN1bHQuY3BwCmluZGV4IDQ1MjFmMmQ4YmNmN2Y5YjU5MzFjMmRlY2I1 MzIxYjRiOWM3NWM2NWIuLjUwZDA1ZWQ1MGNhMTAwZGI3OTQxYmY3ZDA0OGRiNjIyNDUwNTM3YmMg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJIaXRUZXN0UmVzdWx0LmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViSGl0VGVzdFJlc3VsdC5jcHAKQEAgLTExOCw3 ICsxMTgsMTEgQEAgSW50UmVjdCBXZWJIaXRUZXN0UmVzdWx0OjpEYXRhOjplbGVtZW50Qm91bmRp bmdCb3hJbldpbmRvd0Nvb3JkaW5hdGVzKGNvbnN0IEhpdFQKICAgICBpZiAoIXZpZXcpCiAgICAg ICAgIHJldHVybiBJbnRSZWN0KCk7CiAKLSAgICByZXR1cm4gdmlldy0+Y29udGVudHNUb1dpbmRv dyhyZW5kZXJlckJvdW5kaW5nQm94KCpub2RlKSk7CisgICAgUmVuZGVyT2JqZWN0KiByZW5kZXJl ciA9IG5vZGUtPnJlbmRlcmVyKCk7CisgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgcmV0dXJu IEludFJlY3QoKTsKKworICAgIHJldHVybiB2aWV3LT5jb250ZW50c1RvV2luZG93KHJlbmRlcmVy LT5hYnNvbHV0ZUJvdW5kaW5nQm94UmVjdCgpKTsKIH0KIAogfSAvLyBXZWJLaXQKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9Db29yZGluYXRlZEdyYXBoaWNz L1dlYlBhZ2VDb29yZGluYXRlZEdyYXBoaWNzLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nl c3MvV2ViUGFnZS9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlBhZ2VDb29yZGluYXRlZEdyYXBoaWNz LmNwcAppbmRleCAyYmQzN2ZlOWE2NWY1OGI2NDMwNjk0NzgzMGFlZjgzYjQ1YjVkOTYxLi5kZDc0 YWEwOGI0MDU5MzBmNTBmY2QzMGFlMTJiZTdhZDQ0Yjg0YmFmIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJQYWdlQ29v cmRpbmF0ZWRHcmFwaGljcy5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQ YWdlL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViUGFnZUNvb3JkaW5hdGVkR3JhcGhpY3MuY3BwCkBA IC01NSw3ICs1NSw5IEBAIHZvaWQgV2ViUGFnZTo6ZmluZFpvb21hYmxlQXJlYUZvclBvaW50KGNv bnN0IEludFBvaW50JiBwb2ludCwgY29uc3QgSW50U2l6ZSYgYXJlCiAgICAgaWYgKCFub2RlKQog ICAgICAgICByZXR1cm47CiAKLSAgICBJbnRSZWN0IHpvb21hYmxlQXJlYSA9IHJlbmRlcmVyQm91 bmRpbmdCb3goKm5vZGUpOworICAgIEludFJlY3Qgem9vbWFibGVBcmVhOworICAgIGlmIChSZW5k ZXJPYmplY3QqIHJlbmRlcmVyID0gbm9kZS0+cmVuZGVyZXIoKSkKKyAgICAgICAgem9vbWFibGVB cmVhID0gcmVuZGVyZXItPmFic29sdXRlQm91bmRpbmdCb3hSZWN0KCk7CiAKICAgICB3aGlsZSAo dHJ1ZSkgewogICAgICAgICBib29sIGZvdW5kID0gIW5vZGUtPmlzVGV4dE5vZGUoKSAmJiAhbm9k ZS0+aXNTaGFkb3dSb290KCk7CkBAIC03MSw3ICs3Myw4IEBAIHZvaWQgV2ViUGFnZTo6ZmluZFpv b21hYmxlQXJlYUZvclBvaW50KGNvbnN0IEludFBvaW50JiBwb2ludCwgY29uc3QgSW50U2l6ZSYg YXJlCiAgICAgICAgICAgICBicmVhazsKIAogICAgICAgICBub2RlID0gbm9kZS0+cGFyZW50Tm9k ZSgpOwotICAgICAgICB6b29tYWJsZUFyZWEudW5pdGUocmVuZGVyZXJCb3VuZGluZ0JveCgqbm9k ZSkpOworICAgICAgICBpZiAoUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IG5vZGUucmVuZGVyZXIo KSkKKyAgICAgICAgICAgIHpvb21hYmxlQXJlYS51bml0ZShyZW5kZXJlci0+YWJzb2x1dGVCb3Vu ZGluZ0JveFJlY3QoKSk7CiAgICAgfQogCiAgICAgaWYgKG5vZGUtPmRvY3VtZW50KCkuZnJhbWUo KSAmJiBub2RlLT5kb2N1bWVudCgpLmZyYW1lKCktPnZpZXcoKSkgewo=