66472 2011-08-18 08:45:21 -0700 [chromium] Add backend compositor support for rescaling (zooming) textures during zoom animation. 2011-09-08 13:30:15 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 wjmaclean wjmaclean jamesr webkit.review.bot oldest_to_newest 453069 0 wjmaclean 2011-08-18 08:45:21 -0700 [chromium] Add backend compositor support for rescaling (zooming) textures during zoom animation. 453074 1 104349 wjmaclean 2011-08-18 08:53:42 -0700 Created attachment 104349 Patch 453084 2 wjmaclean 2011-08-18 09:37:37 -0700 Some background: this patch provides back end support for an experimental zoom animation feature. For now this patch is relatively inactive, but I'd like to get it in place now so it's easier to maintain w.r.t. chromium's compositor changes. The front-end patch will follow in a couple of days. 453093 3 jamesr 2011-08-18 09:49:42 -0700 Figure out a way for this to be tested before trying to check it in. we will not be able to maintain a feature like this without tests. 453150 4 wjmaclean 2011-08-18 11:04:57 -0700 (In reply to comment #3) > Figure out a way for this to be tested before trying to check it in. we will not be able to maintain a feature like this without tests. Hmmm. The only way I can think of to do this without including the front-end zoom animator stuff is a compositor unit test. Do such things exist? My initial perusal of the chromium port directories didn't turn up any examples ... 453154 5 jamesr 2011-08-18 11:09:12 -0700 We do, see Source/WebKit/chromium/tests/. There are not many tests now, but it would be great to have more :) Another option is to expose the zoom level through window.internals and construct normal layout tests with different zoom levels. See http://trac.webkit.org/changeset/92697 for one example of how this can be done. 453216 6 wjmaclean 2011-08-18 11:59:39 -0700 (In reply to comment #5) > > Another option is to expose the zoom level through window.internals and construct normal layout tests with different zoom levels. See http://trac.webkit.org/changeset/92697 for one example of how this can be done. I like this option, except that unlike forcing the compositor on, plumbing through the zoom scale creates all sorts of code in settings that exists purely for the sake of the test. Is there some way to mitigate this excess baggage? Having pixel comparisons in a layout test seems kinda necessary. 453238 7 jamesr 2011-08-18 12:20:13 -0700 (In reply to comment #6) > (In reply to comment #5) > > > > Another option is to expose the zoom level through window.internals and construct normal layout tests with different zoom levels. See http://trac.webkit.org/changeset/92697 for one example of how this can be done. > > I like this option, except that unlike forcing the compositor on, plumbing through the zoom scale creates all sorts of code in settings that exists purely for the sake of the test. Is there some way to mitigate this excess baggage? How much of this baggage is really redundant with the frontend code? > > Having pixel comparisons in a layout test seems kinda necessary. Well that depends on what you want to test. If you want to test that the rendered output is correct, then you probably do need the pixels. 453248 8 wjmaclean 2011-08-18 12:31:57 -0700 (In reply to comment #7) > (In reply to comment #6) > > (In reply to comment #5) > > > > > > Another option is to expose the zoom level through window.internals and construct normal layout tests with different zoom levels. See http://trac.webkit.org/changeset/92697 for one example of how this can be done. > > > > I like this option, except that unlike forcing the compositor on, plumbing through the zoom scale creates all sorts of code in settings that exists purely for the sake of the test. Is there some way to mitigate this excess baggage? > > How much of this baggage is really redundant with the frontend code? When the feature is finished, there is no way to affect it through settings, so all the code in WebSettings, WebSettingsImpl is kind of wasted. I suppose it could go behind a define, but then it wouldn't get tested. It's really just 4 accessors, one member var (in WebSettingsImpl), and one extra line of code in WebViewImpl, but still it has no purpose beyond facilitating the test. I suppose we could yank the extra baggage out in a separate CL after the front-end code lands? > > > > Having pixel comparisons in a layout test seems kinda necessary. > > Well that depends on what you want to test. If you want to test that the rendered output is correct, then you probably do need the pixels. The scale factor, which is used to shrink/enlarge a texture during a zoom animation, is only used to quickly display the effects of a zoom during the animation, without having to re-layout (i.e. we quickly re-composite the existing layer textures without redrawing). The only meaningful test (I can think of) is either (1) the gl matrix (but there's a separate one for each layer and they'd be hard to expose), and (2) the pixels themselves. So I think I'd need the pixels. 453262 9 jamesr 2011-08-18 12:38:31 -0700 (In reply to comment #8) > (In reply to comment #7) > > (In reply to comment #6) > > > (In reply to comment #5) > > > > > > > > Another option is to expose the zoom level through window.internals and construct normal layout tests with different zoom levels. See http://trac.webkit.org/changeset/92697 for one example of how this can be done. > > > > > > I like this option, except that unlike forcing the compositor on, plumbing through the zoom scale creates all sorts of code in settings that exists purely for the sake of the test. Is there some way to mitigate this excess baggage? > > > > How much of this baggage is really redundant with the frontend code? > > When the feature is finished, there is no way to affect it through settings, so all the code in WebSettings, WebSettingsImpl is kind of wasted. I suppose it could go behind a define, but then it wouldn't get tested. > > It's really just 4 accessors, one member var (in WebSettingsImpl), and one extra line of code in WebViewImpl, but still it has no purpose beyond facilitating the test. I agree that it sucks to have to go through WebSettings, but testing is important. > > I suppose we could yank the extra baggage out in a separate CL after the front-end code lands? And test it some other way? > > > > > > > Having pixel comparisons in a layout test seems kinda necessary. > > > > Well that depends on what you want to test. If you want to test that the rendered output is correct, then you probably do need the pixels. > > The scale factor, which is used to shrink/enlarge a texture during a zoom animation, is only used to quickly display the effects of a zoom during the animation, without having to re-layout (i.e. we quickly re-composite the existing layer textures without redrawing). The only meaningful test (I can think of) is either (1) the gl matrix (but there's a separate one for each layer and they'd be hard to expose), and (2) the pixels themselves. > > So I think I'd need the pixels. Right. 453276 10 wjmaclean 2011-08-18 12:49:55 -0700 (In reply to comment #9) > > And test it some other way? Yes, once the front-end is in place, then it can be tested through a zoom gesture test. I nearly have a revised patch figured out, will post shortly ... 453288 11 jamesr 2011-08-18 13:04:40 -0700 Note that you will probably also have some merge conflicts to sort out with http://trac.webkit.org/changeset/93329 453296 12 wjmaclean 2011-08-18 13:16:13 -0700 (In reply to comment #11) > Note that you will probably also have some merge conflicts to sort out with http://trac.webkit.org/changeset/93329 OK, so the new patch may not happen as soon as expected :-( 459778 13 105804 wjmaclean 2011-08-31 11:36:45 -0700 Created attachment 105804 Patch 459782 14 wjmaclean 2011-08-31 11:40:14 -0700 (In reply to comment #12) > (In reply to comment #11) > > Note that you will probably also have some merge conflicts to sort out with http://trac.webkit.org/changeset/93329 > > OK, so the new patch may not happen as soon as expected :-( It's here, updated to account for recent changes to LayerRendererChromium, and with a layout test. 461453 15 105804 jamesr 2011-09-02 13:04:43 -0700 Comment on attachment 105804 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=105804&action=review Thanks for the test. The code looks pretty sane (although you've got a lot of merge conflicts now. pardon our dust!) I'm not really sure what is going on with the test, though. What would the test display if the test failed? Normally we try to construct tests to that you see red if it fails and green if it passes, if that's feasible, and otherwise we try to describe the output you should see in the test (in an HTML comment or the like). I can't tell if that test is passing or failing just from looking at it. It would also be good to have tests for >1 zooms as well as <1. I'm also a little confused about whether the non-initialized compositor blue is showing up in the test or if that's part of the test page. We probably shouldn't be showing the uninitialized blue ever, right? > LayoutTests/platform/chromium/compositing/zoom-animator-scale-test.html:9 > + if (window.layoutTestController) > + window.layoutTestController.waitUntilDone(); please also call layoutTestController.dumpAsText(true) to indicate that the pixel output is the only thing needed 461462 16 wjmaclean 2011-09-02 13:15:16 -0700 (In reply to comment #15) > (From update of attachment 105804 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=105804&action=review > > Thanks for the test. The code looks pretty sane (although you've got a lot of merge conflicts now. pardon our dust!) > > I'm not really sure what is going on with the test, though. What would the test display if the test failed? Normally we try to construct tests to that you see red if it fails and green if it passes, if that's feasible, and otherwise we try to describe the output you should see in the test (in an HTML comment or the like). I can't tell if that test is passing or failing just from looking at it. It would also be good to have tests for >1 zooms as well as <1. I'm also a little confused about whether the non-initialized compositor blue is showing up in the test or if that's part of the test page. We probably shouldn't be showing the uninitialized blue ever, right? > > > LayoutTests/platform/chromium/compositing/zoom-animator-scale-test.html:9 > > + if (window.layoutTestController) > > + window.layoutTestController.waitUntilDone(); > > please also call layoutTestController.dumpAsText(true) to indicate that the pixel output is the only thing needed For the short term, the uninitialized blue needs to e part of the test (ask me about this offline). I can add the description of the expected result, plus a >1 test, plus the dumpAsText call (once I get out of merge hell ;-) ). 462658 17 wjmaclean 2011-09-06 10:59:22 -0700 (In reply to comment #15) Base on our chat on Friday, you suggested I follow the example of setViewport as to how I can plumb the call to setTextureZoom. I did this, placing the call to hostImpl->setTextureZoom (my code) inside CCLayerTreeHost::preCommit(). And this worked. But now preCommit() is gone, and moving the plumbing to commitTo() doesn't seem to work the same (although this is where setViewport has moved to). So I'm not sure now where to put this, and what the difference is between preCommit and commitTo. The ultimate problem is this: how to get the textureZoom value from WebViewImpl to LayerRendererChromium. 462702 18 wjmaclean 2011-09-06 11:42:54 -0700 (In reply to comment #17) > (In reply to comment #15) > > Base on our chat on Friday, you suggested I follow the example of setViewport as to how I can plumb the call to setTextureZoom. I did this, placing the call to hostImpl->setTextureZoom (my code) inside CCLayerTreeHost::preCommit(). And this worked. > > But now preCommit() is gone, and moving the plumbing to commitTo() doesn't seem to work the same (although this is where setViewport has moved to). > > So I'm not sure now where to put this, and what the difference is between preCommit and commitTo. > > The ultimate problem is this: how to get the textureZoom value from WebViewImpl to LayerRendererChromium. OK, after putting this under the debugger it seems commitTo() should work, but isn't getting called. CCSingleThreadProxy seems to be trying to call it, but when I go to step in in gdb it seems to just continue the program (as if it had been optimised out?). 462744 19 wjmaclean 2011-09-06 12:34:57 -0700 (In reply to comment #18) > (In reply to comment #17) > > (In reply to comment #15) > > > > Base on our chat on Friday, you suggested I follow the example of setViewport as to how I can plumb the call to setTextureZoom. I did this, placing the call to hostImpl->setTextureZoom (my code) inside CCLayerTreeHost::preCommit(). And this worked. > > > > But now preCommit() is gone, and moving the plumbing to commitTo() doesn't seem to work the same (although this is where setViewport has moved to). > > > > So I'm not sure now where to put this, and what the difference is between preCommit and commitTo. > > > > The ultimate problem is this: how to get the textureZoom value from WebViewImpl to LayerRendererChromium. > > OK, after putting this under the debugger it seems commitTo() should work, but isn't getting called. CCSingleThreadProxy seems to be trying to call it, but when I go to step in in gdb it seems to just continue the program (as if it had been optimised out?). So the plumbing looks OK, so I'm guessing something else has changed in LRC ... please ignore until I've had a chance to look at it further ... 462763 20 106470 wjmaclean 2011-09-06 12:49:40 -0700 Created attachment 106470 Patch 462765 21 wjmaclean 2011-09-06 12:52:46 -0700 (In reply to comment #20) > Created an attachment (id=106470) [details] > Patch I believe this patch addresses most of your concerns. The one outstanding item is the debug blue clear colour in the one layout test. At some point we will draw the un-composited region with some texture, but temporarily (until we get the front end stuff in) I'd like to leave this test as is. I've set a test expectation to skip this one test in GPU RELEASE mode ... please let me know if I've done this correctly. 462920 22 106470 jamesr 2011-09-06 15:31:16 -0700 Comment on attachment 106470 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=106470&action=review The settings stuff isn't right. I'm not sure you need to edit WebSettings or WebSettingsImpl at all, I can't find any code in this patch that uses that logic and it seems wrong (there's nothing to propagate sets on WebSettings to Settings that I can see). > LayoutTests/platform/chromium-gpu-linux/platform/chromium/compositing/zoom-animator-scale-test-expected.txt:7 > +layer at (0,0) size 800x600 > + RenderView at (0,0) size 800x600 > +layer at (0,0) size 800x600 > + RenderBlock {HTML} at (0,0) size 800x600 > + RenderBody {BODY} at (8,8) size 784x584 > +layer at (100,100) size 100x100 > + RenderBlock (positioned) {DIV} at (100,100) size 100x100 [bgcolor=#0000FF] there shouldn't be a rendertree dump for this test > LayoutTests/platform/chromium/compositing/zoom-animator-scale-test.html:9 > + if (window.layoutTestController) > + window.layoutTestController.waitUntilDone(); this should be dumpAsText(true) there also should be some sort of comment somewhere in this .html explaining what we should see in a pass > LayoutTests/platform/chromium/test_expectations.txt:2590 > +// This is a temporary test that relies on the debug-clear colour, so don't bother > +// in release mode. > +WONTFIX SKIP GPU RELEASE : platform/chromium/compositing/zoom-animator-scale-test.html = IMAGE we clear to blue in release mode too, so this should pass in release mode - does it not? we should _not_ skip this test in release. at most, mark it as = IMAGE (although i doubt that is necessary) > Source/WebCore/testing/Internals.cpp:252 > + document->settings()->setZoomAnimatorScale(scale); this is setting it on the WebCore::Settings object, right? Do you need to modify WebKit::WebSettings at all? > Source/WebKit/chromium/public/WebSettings.h:108 > + virtual double getZoomAnimatorScale() = 0; this is incorrectly named, but it also seems uncalled so maybe just delete it > Source/WebKit/chromium/src/WebSettingsImpl.cpp:325 > + if (scale > 0.0) > + m_zoomAnimatorScale = scale; why doesn't this just set the value on m_settings ? > Source/WebKit/chromium/src/WebSettingsImpl.h:100 > + virtual double getZoomAnimatorScale() { return m_zoomAnimatorScale; } we don't prefix getters with "get" in WebKit, this should be just zoomAnimatorScale() if it's here at all why is this needed? who queries a WebSettingsImpl for this value (as opposed to a Settings)? > Source/WebKit/chromium/src/WebSettingsImpl.h:132 > + > + double m_zoomAnimatorScale; i don't understand why this is here 463364 23 wjmaclean 2011-09-07 08:34:16 -0700 (In reply to comment #22) > (From update of attachment 106470 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=106470&action=review > > The settings stuff isn't right. I'm not sure you need to edit WebSettings or WebSettingsImpl at all, I can't find any code in this patch that uses that logic and it seems wrong (there's nothing to propagate sets on WebSettings to Settings that I can see). > > > LayoutTests/platform/chromium-gpu-linux/platform/chromium/compositing/zoom-animator-scale-test-expected.txt:7 > > +layer at (0,0) size 800x600 > > + RenderView at (0,0) size 800x600 > > +layer at (0,0) size 800x600 > > + RenderBlock {HTML} at (0,0) size 800x600 > > + RenderBody {BODY} at (8,8) size 784x584 > > +layer at (100,100) size 100x100 > > + RenderBlock (positioned) {DIV} at (100,100) size 100x100 [bgcolor=#0000FF] > > there shouldn't be a rendertree dump for this test Fixed. > > LayoutTests/platform/chromium/compositing/zoom-animator-scale-test.html:9 > > + if (window.layoutTestController) > > + window.layoutTestController.waitUntilDone(); > > this should be dumpAsText(true) Fixed. > there also should be some sort of comment somewhere in this .html explaining what we should see in a pass > > > LayoutTests/platform/chromium/test_expectations.txt:2590 > > +// This is a temporary test that relies on the debug-clear colour, so don't bother > > +// in release mode. > > +WONTFIX SKIP GPU RELEASE : platform/chromium/compositing/zoom-animator-scale-test.html = IMAGE > > we clear to blue in release mode too, so this should pass in release mode - does it not? > > we should _not_ skip this test in release. at most, mark it as = IMAGE (although i doubt that is necessary) It passes, updated test_expectations to remove this. > > Source/WebCore/testing/Internals.cpp:252 > > + document->settings()->setZoomAnimatorScale(scale); > > this is setting it on the WebCore::Settings object, right? Do you need to modify WebKit::WebSettings at all? At some point in time I apparently did, but you're right that it's not necessary. I've removed all the WebSettings stuff (this should address all remaining comments). > > Source/WebKit/chromium/public/WebSettings.h:108 > > + virtual double getZoomAnimatorScale() = 0; > > this is incorrectly named, but it also seems uncalled so maybe just delete it > > > Source/WebKit/chromium/src/WebSettingsImpl.cpp:325 > > + if (scale > 0.0) > > + m_zoomAnimatorScale = scale; > > why doesn't this just set the value on m_settings ? > > > Source/WebKit/chromium/src/WebSettingsImpl.h:100 > > + virtual double getZoomAnimatorScale() { return m_zoomAnimatorScale; } > > we don't prefix getters with "get" in WebKit, this should be just zoomAnimatorScale() if it's here at all > > why is this needed? who queries a WebSettingsImpl for this value (as opposed to a Settings)? > > > Source/WebKit/chromium/src/WebSettingsImpl.h:132 > > + > > + double m_zoomAnimatorScale; > > i don't understand why this is here 463365 24 106587 wjmaclean 2011-09-07 08:37:49 -0700 Created attachment 106587 Patch 463366 25 wjmaclean 2011-09-07 08:38:54 -0700 (In reply to comment #24) > Created an attachment (id=106587) [details] > Patch webbkit-patch didn't create an entry for LayoutTests/Changelog ... is that right? 463770 26 106587 jamesr 2011-09-07 16:46:08 -0700 Comment on attachment 106587 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=106587&action=review After thinking about it, I really think that depending on the uninitialized compositor blue is an absolute no-go for me. We really want to change that behavior ASAP and having a test that depends on it is just going to be a mess. Until you get the frontend in (which will presumably fix this) could you just remove the <1 zoom factor test? As a general note, I wish that you would be a little more careful about adding unnecessary getters. If you end up adding a function and it never gets called, that's a sign that you need to think a little bit more about whether that getter really should be part of the object's interface or not. > LayoutTests/platform/chromium/compositing/zoom-animator-scale-test2.html:13 > + document.getElementById("aBox").style.backgroundColor = "#0000FF"; // Change to blue we prefer green to blue for 'good' in layout tests. you can also just set the backgroundColor to "blue" and not need the comment > Source/WebCore/page/Settings.cpp:219 > + , m_zoomAnimatorScale(1.0) webkit style prefers '1' for constants like this instead of 1.0 unless the type is necessary (which it isn't here) > Source/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:166 > + , m_textureZoom(1.0) 1 why is it zoomAnimatorScale in Settings and m_textureZoom here? I think zoomAnimatorScale makes more sense > Source/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:299 > + if (m_textureZoom != 1.0) > + zoomMatrix.scale3d(m_textureZoom, m_textureZoom, 1.0); i'm not sure why this scale is conditional but the other scales (like in CCLayerTreeHost) are not. is there any particular reason? > Source/WebCore/platform/graphics/chromium/LayerRendererChromium.h:113 > + double getTextureZoom() { return m_textureZoom; } nack, no 'get' on getters. does anybody call this? it looks like the zoom value is only used in this class directly, so i don't see any reason to add a getter at all > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:57 > + , m_textureZoom(1.0) 1 > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:119 > + hostImpl->setTextureZoom(textureZoom()); why doesn't this just use m_textureZoom? then you wouldn't need a getter > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:187 > +void CCLayerTreeHost::setTextureZoom(const double zoom) the 'const' here doesn't seem to add much since this is already passed by value > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h:133 > + void setTextureZoom(const double); 'const double' as a parameter type makes zero sense. the double is passed by value (obviously) so const doesn't change the semantics > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h:152 > + double textureZoom() const { return m_textureZoom; } nobody calls this, remove it > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:50 > + , m_textureZoom(1.0) 1 > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:161 > +void CCLayerTreeHostImpl::setTextureZoom(double zoom) > +{ > + m_textureZoom = zoom; why are we storing this on the CCLayerTreeHostImpl at all? we never use this value, only the LayerRendererChromium uses it. > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:91 > + double m_textureZoom; why does this store the textureZoom value if the LayerRendererChromium is also storing it? > Source/WebKit/chromium/src/WebViewImpl.cpp:1827 > + m_layerTreeHost->setTextureZoom(1.0); 1.0 should be 1 > Source/WebKit/chromium/src/WebViewImpl.cpp:2573 > { > -#if USE(THREADED_COMPOSITING) > if (m_layerTreeHost) > - m_layerTreeHost->setNeedsCommitAndRedraw(); > -#else > + m_layerTreeHost->setTextureZoom(m_page->settings()->zoomAnimatorScale()); > +#if !USE(THREADED_COMPOSITING) > m_client->scheduleComposite(); > #endif Is this a bad merge? This change doesn't look right.... 464028 27 wjmaclean 2011-09-08 07:25:40 -0700 (In reply to comment #26) > (From update of attachment 106587 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=106587&action=review > > After thinking about it, I really think that depending on the uninitialized compositor blue is an absolute no-go for me. We really want to change that behavior ASAP and having a test that depends on it is just going to be a mess. > > Until you get the frontend in (which will presumably fix this) could you just remove the <1 zoom factor test? Removed. > As a general note, I wish that you would be a little more careful about adding unnecessary getters. If you end up adding a function and it never gets called, that's a sign that you need to think a little bit more about whether that getter really should be part of the object's interface or not. I don't do this on purpose. In most cases these result from evolution of the patch, where the getter is used, and then obsoleted. It's a mistake when I don't spot them before submitting, but I do appreciate your catching them. I will try to do a better job of finding/removing these in future. > > LayoutTests/platform/chromium/compositing/zoom-animator-scale-test2.html:13 > > + document.getElementById("aBox").style.backgroundColor = "#0000FF"; // Change to blue > > we prefer green to blue for 'good' in layout tests. you can also just set the backgroundColor to "blue" and not need the comment Done and done. > > Source/WebCore/page/Settings.cpp:219 > > + , m_zoomAnimatorScale(1.0) > > webkit style prefers '1' for constants like this instead of 1.0 unless the type is necessary (which it isn't here) Fixed (This is something about WebKit style I've yet to get used to.) > > Source/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:166 > > + , m_textureZoom(1.0) > > 1 Fixed. > why is it zoomAnimatorScale in Settings and m_textureZoom here? I think zoomAnimatorScale makes more sense Changes made at different times. I've made everything zoomAnimatorScale. > > Source/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:299 > > + if (m_textureZoom != 1.0) > > + zoomMatrix.scale3d(m_textureZoom, m_textureZoom, 1.0); > > i'm not sure why this scale is conditional but the other scales (like in CCLayerTreeHost) are not. is there any particular reason? Originally, I put this in as a guard in case scale3d was expensive, although this is probably overly cautious on my part. When half the scale computations jumped ship the conditional got lost in the merge. > > Source/WebCore/platform/graphics/chromium/LayerRendererChromium.h:113 > > + double getTextureZoom() { return m_textureZoom; } > > nack, no 'get' on getters. does anybody call this? it looks like the zoom value is only used in this class directly, so i don't see any reason to add a getter at all Removed. The getter was originally necessary when debug border transforms were handled differently and in a different file. Now they've been reconciled, it's no longer needed. > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:57 > > + , m_textureZoom(1.0) > > 1 Fixed. > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:119 > > + hostImpl->setTextureZoom(textureZoom()); > > why doesn't this just use m_textureZoom? then you wouldn't need a getter I was following the same pattern as the line below this code (where viewportSize() is used instead of m_viewportSize). Fixed. > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:187 > > +void CCLayerTreeHost::setTextureZoom(const double zoom) > > the 'const' here doesn't seem to add much since this is already passed by value Fixed. > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h:133 > > + void setTextureZoom(const double); > > 'const double' as a parameter type makes zero sense. the double is passed by value (obviously) so const doesn't change the semantics > > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h:152 > > + double textureZoom() const { return m_textureZoom; } > > nobody calls this, remove it Fixed. > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:50 > > + , m_textureZoom(1.0) > > 1 Fixed. > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:161 > > +void CCLayerTreeHostImpl::setTextureZoom(double zoom) > > +{ > > + m_textureZoom = zoom; > > why are we storing this on the CCLayerTreeHostImpl at all? we never use this value, only the LayerRendererChromium uses it. Fixed. > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:91 > > + double m_textureZoom; > > why does this store the textureZoom value if the LayerRendererChromium is also storing it? As above. > > Source/WebKit/chromium/src/WebViewImpl.cpp:1827 > > + m_layerTreeHost->setTextureZoom(1.0); > > 1.0 should be 1 Fixed. > > Source/WebKit/chromium/src/WebViewImpl.cpp:2573 > > { > > -#if USE(THREADED_COMPOSITING) > > if (m_layerTreeHost) > > - m_layerTreeHost->setNeedsCommitAndRedraw(); > > -#else > > + m_layerTreeHost->setTextureZoom(m_page->settings()->zoomAnimatorScale()); > > +#if !USE(THREADED_COMPOSITING) > > m_client->scheduleComposite(); > > #endif > > Is this a bad merge? This change doesn't look right.... No, just a last-minute mistake. Fixed. Thanks for all your patience on this ... it's been a challenging patch to keep alive. 464029 28 106732 wjmaclean 2011-09-08 07:25:56 -0700 Created attachment 106732 Patch 464030 29 wjmaclean 2011-09-08 07:28:09 -0700 (In reply to comment #28) > Created an attachment (id=106732) [details] > Patch I've re-included an (empty) text expected output file, since dumpAsText(true) seems to require one (at least, running the test through new-run-webkit-tests seems to crete it, whether I'm re-baselining or not). If this is not OK, let me know what can be done about it. 464146 30 106732 jamesr 2011-09-08 10:37:21 -0700 Comment on attachment 106732 Patch R=me. the -expected.txt is correct and expected 464150 31 wjmaclean 2011-09-08 10:39:12 -0700 (In reply to comment #30) > (From update of attachment 106732 [details]) > R=me. > > the -expected.txt is correct and expected Thanks! 464297 32 106732 webkit.review.bot 2011-09-08 13:30:10 -0700 Comment on attachment 106732 Patch Clearing flags on attachment: 106732 Committed r94789: <http://trac.webkit.org/changeset/94789> 464298 33 webkit.review.bot 2011-09-08 13:30:15 -0700 All reviewed patches have been landed. Closing bug. 104349 2011-08-18 08:53:42 -0700 2011-08-31 11:36:40 -0700 Patch bug-66472-20110818115414.patch text/plain 9542 wjmaclean U3VidmVyc2lvbiBSZXZpc2lvbjogOTMzMDkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA1MWYyYWFiOGMyMTcyNzBm YzVhYWJjMWM5OTIzYTQ1MGNiNTU4YjgzLi5mNWYyOWZjZWExNDYzYTdiZDE0OWNmOTI0YmVjYWRj MDVkMTRjMmQ1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMTEtMDgtMTggIFcuIEph bWVzIE1hY0xlYW4gIDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1 bV0gQWRkIGJhY2tlbmQgY29tcG9zaXRvciBzdXBwb3J0IGZvciByZXNjYWxpbmcgKHpvb21pbmcp IHRleHR1cmVzIGR1cmluZyB6b29tIGFuaW1hdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY2NDcyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzICh0byBiZSBhZGRlZCBsYXllciwg d2hlbiBmcm9udC1lbmQgc3VwcG9ydCBhZGRlZCBmb3Igem9vbSBhbmltYXRpb24pLgorCisgICAg ICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6TGF5ZXJSZW5kZXJl ckNocm9taXVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6aW5p dGlhbGl6ZSk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OmRyYXdS b290TGF5ZXIpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjp1cGRh dGVMYXllcnMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVu ZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVt OjpzZXRUZXh0dXJlWm9vbSk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21p dW06OmdldFRleHR1cmVab29tKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ0xheWVySW1wbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVySW1wbDo6ZHJh d0RlYnVnQm9yZGVyKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9D Q0xheWVyVHJlZUhvc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q0NMYXllclRyZWVIb3N0Ojpz ZXRUZXh0dXJlWm9vbSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NMYXllclRyZWVIb3N0Lmg6CisKIDIwMTEtMDgtMTggIFBhdmVsIFBvZGl2aWxvdiAgPHBvZGl2 aWxvdkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogZXh0cmFjdCBjb250 ZW50IGxvYWRpbmcgZnVuY3Rpb25zIGZyb20gUmF3U291cmNlQ29kZSB0byBDb250ZW50UHJvdmlk ZXIgaW1wbGVtZW50YXRpb25zLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAK aW5kZXggYjdjNTJiYzQzZjEwZGM2M2Q3YjRjZmNkZGJmNGVhNWRhMjIwZmQ1YS4uZmNlZDU4MWRi Njk5ZmI2OWEyZjYzMTJkNzM1YWE3ZDBmMTQ1YWZmNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uY3BwCkBAIC00NTUsNiArNDU1LDcgQEAgTGF5ZXJSZW5kZXJlckNocm9taXVt OjpMYXllclJlbmRlcmVyQ2hyb21pdW0oQ0NMYXllclRyZWVIb3N0KiBvd25lciwKICAgICA6IG1f b3duZXIob3duZXIpCiAgICAgLCBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlKDApCiAgICAgLCBtX29m ZnNjcmVlbkZyYW1lYnVmZmVySWQoMCkKKyAgICAsIG1fdGV4dHVyZVpvb20oMS4wKQogICAgICwg bV9jb250ZXh0KGNvbnRleHQpCiAgICAgLCBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKDApCiB7CkBA IC00ODUsNyArNDg2LDExIEBAIGJvb2wgTGF5ZXJSZW5kZXJlckNocm9taXVtOjppbml0aWFsaXpl KCkKICNlbmRpZgogICAgICAgICBtX3Jvb3RMYXllclRleHR1cmVVcGRhdGVyID0gTGF5ZXJUZXh0 dXJlVXBkYXRlckJpdG1hcDo6Y3JlYXRlKG1fY29udGV4dC5nZXQoKSwgbV9vd25lci0+Y3JlYXRl Um9vdExheWVyUGFpbnRlcigpLCBtX2NvbnRleHRTdXBwb3J0c01hcFN1Yik7CiAKKyNpZiBFTkFC TEUoVE9VQ0hfRVZFTlRTKQorICAgIG1fcm9vdExheWVyQ29udGVudFRpbGVyID0gTGF5ZXJUaWxl ckNocm9taXVtOjpjcmVhdGUodGhpcywgSW50U2l6ZSgyNTYsIDI1NiksIExheWVyVGlsZXJDaHJv bWl1bTo6SGFzQm9yZGVyVGV4ZWxzKTsKKyNlbHNlCiAgICAgbV9yb290TGF5ZXJDb250ZW50VGls ZXIgPSBMYXllclRpbGVyQ2hyb21pdW06OmNyZWF0ZSh0aGlzLCBJbnRTaXplKDI1NiwgMjU2KSwg TGF5ZXJUaWxlckNocm9taXVtOjpOb0JvcmRlclRleGVscyk7CisjZW5kaWYKICAgICBBU1NFUlQo bV9yb290TGF5ZXJDb250ZW50VGlsZXIpOwogCiAgICAgbV9oZWFkc1VwRGlzcGxheSA9IENDSGVh ZHNVcERpc3BsYXk6OmNyZWF0ZSh0aGlzKTsKQEAgLTUzNiw2ICs1NDEsOCBAQCB2b2lkIExheWVy UmVuZGVyZXJDaHJvbWl1bTo6dXBkYXRlUm9vdExheWVyQ29udGVudHMoKQogdm9pZCBMYXllclJl bmRlcmVyQ2hyb21pdW06OmRyYXdSb290TGF5ZXIoKQogewogICAgIFRyYW5zZm9ybWF0aW9uTWF0 cml4IHNjcm9sbDsKKyAgICBpZiAobV90ZXh0dXJlWm9vbSAhPSAxLjApCisgICAgICAgIHNjcm9s bC5zY2FsZTNkKG1fdGV4dHVyZVpvb20sIG1fdGV4dHVyZVpvb20sIDEuMCk7CiAgICAgc2Nyb2xs LnRyYW5zbGF0ZSgtbV9vd25lci0+dmlld3BvcnRWaXNpYmxlUmVjdCgpLngoKSwgLW1fb3duZXIt PnZpZXdwb3J0VmlzaWJsZVJlY3QoKS55KCkpOwogCiAgICAgbV9yb290TGF5ZXJDb250ZW50VGls ZXItPmRyYXcobV9vd25lci0+dmlld3BvcnRWaXNpYmxlUmVjdCgpLCBzY3JvbGwsIDEuMGYpOwpA QCAtNjM4LDExICs2NDUsMTMgQEAgdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnVwZGF0ZUxh eWVycyhMYXllckNocm9taXVtKiByb290TGF5ZXIpCiAgICAgUmVuZGVyU3VyZmFjZUNocm9taXVt KiByb290UmVuZGVyU3VyZmFjZSA9IHJvb3RMYXllci0+cmVuZGVyU3VyZmFjZSgpOwogICAgIHJv b3RSZW5kZXJTdXJmYWNlLT5jbGVhckxheWVyTGlzdCgpOwogCi0gICAgVHJhbnNmb3JtYXRpb25N YXRyaXggaWRlbnRpdHlNYXRyaXg7CisgICAgVHJhbnNmb3JtYXRpb25NYXRyaXggem9vbU1hdHJp eDsKKyAgICBpZiAobV90ZXh0dXJlWm9vbSAhPSAxLjApCisgICAgICAgIHpvb21NYXRyaXguc2Nh bGUzZChtX3RleHR1cmVab29tLCBtX3RleHR1cmVab29tLCAxLjApOwogCiAgICAgewogICAgICAg ICBUUkFDRV9FVkVOVCgiTGF5ZXJSZW5kZXJlckNocm9taXVtOjp1cGRhdGVMYXllcnM6OmNhbGNE cmF3RXRjIiwgdGhpcywgMCk7Ci0gICAgICAgIGNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zQW5kVmlz aWJpbGl0eTxMYXllckNocm9taXVtLCBSZW5kZXJTdXJmYWNlQ2hyb21pdW0sIHZvaWQqPihyb290 TGF5ZXIsIHJvb3RMYXllciwgaWRlbnRpdHlNYXRyaXgsIHJlbmRlclN1cmZhY2VMYXllckxpc3Qs IHJvb3RSZW5kZXJTdXJmYWNlLT5sYXllckxpc3QoKSwgMCwgbV9tYXhUZXh0dXJlU2l6ZSk7Cisg ICAgICAgIGNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zQW5kVmlzaWJpbGl0eTxMYXllckNocm9taXVt LCBSZW5kZXJTdXJmYWNlQ2hyb21pdW0sIHZvaWQqPihyb290TGF5ZXIsIHJvb3RMYXllciwgem9v bU1hdHJpeCwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCwgcm9vdFJlbmRlclN1cmZhY2UtPmxheWVy TGlzdCgpLCAwLCBtX21heFRleHR1cmVTaXplKTsKICAgICB9CiAKICNpZm5kZWYgTkRFQlVHCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXll clJlbmRlcmVyQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCmluZGV4IGZhNzBjZjZiNjhjYTZmOTY1ZTUy NDE4ZWUzNjljZWRiYjljN2FlOGIuLjdjNGViOTg5ZDVmYzJjOTAwMTM5ZGNkYTE4Y2ExYzA2MWM0 YjhmZmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC0xMDYsNiArMTA2 LDkgQEAgcHVibGljOgogICAgIC8vIHB1dHMgYmFja2J1ZmZlciBvbnNjcmVlbgogICAgIHZvaWQg cHJlc2VudCgpOwogCisgICAgdm9pZCBzZXRUZXh0dXJlWm9vbShkb3VibGUgZmFjdG9yKSB7IG1f dGV4dHVyZVpvb20gPSBmYWN0b3I7IH0KKyAgICBkb3VibGUgZ2V0VGV4dHVyZVpvb20oKSB7IHJl dHVybiBtX3RleHR1cmVab29tOyB9CisKICAgICB1bnNpZ25lZCBjcmVhdGVMYXllclRleHR1cmUo KTsKICAgICB2b2lkIGRlbGV0ZUxheWVyVGV4dHVyZSh1bnNpZ25lZCk7CiAKQEAgLTIxMSw2ICsy MTQsNyBAQCBwcml2YXRlOgogCiAgICAgQ0NSZW5kZXJTdXJmYWNlKiBtX2N1cnJlbnRSZW5kZXJT dXJmYWNlOwogICAgIHVuc2lnbmVkIG1fb2Zmc2NyZWVuRnJhbWVidWZmZXJJZDsKKyAgICBkb3Vi bGUgbV90ZXh0dXJlWm9vbTsKIAogICAgIC8vIE1heGltdW0gdGV4dHVyZSBkaW1lbnNpb25zIHN1 cHBvcnRlZC4KICAgICBpbnQgbV9tYXhUZXh0dXJlU2l6ZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJJbXBsLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJJbXBsLmNw cAppbmRleCAzY2VhZDRjMTJjMzU1MTJmODU4OTM0ZTU5Y2ZhMTAxMDI0MTcxN2I2Li5hMDVhYzQ2 OTlhODVlNThhZDgzNjVkMmEyNjFhOWY3ZmMwYjM2YjE2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVySW1wbC5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllckltcGwu Y3BwCkBAIC0xNzEsNyArMTcxLDE1IEBAIHZvaWQgQ0NMYXllckltcGw6OmRyYXdEZWJ1Z0JvcmRl cigpCiAKICAgICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCByZW5kZXJNYXRyaXggPSBkcmF3VHJhbnNm b3JtKCk7CiAgICAgcmVuZGVyTWF0cml4LnNjYWxlM2QoYm91bmRzKCkud2lkdGgoKSwgYm91bmRz KCkuaGVpZ2h0KCksIDEpOwotICAgIHRvR0xNYXRyaXgoJmdsTWF0cml4WzBdLCBsYXllclJlbmRl cmVyKCktPnByb2plY3Rpb25NYXRyaXgoKSAqIHJlbmRlck1hdHJpeCk7CisKKyAgICBkb3VibGUg em9vbUZhY3RvciA9IGxheWVyUmVuZGVyZXIoKS0+Z2V0VGV4dHVyZVpvb20oKTsKKyAgICBpZiAo em9vbUZhY3RvciAhPSAxLjApIHsKKyAgICAgICAgVHJhbnNmb3JtYXRpb25NYXRyaXggem9vbVNj YWxlOworICAgICAgICB6b29tU2NhbGUuc2NhbGUzZCh6b29tRmFjdG9yLCB6b29tRmFjdG9yLCAx LjApOworICAgICAgICB0b0dMTWF0cml4KCZnbE1hdHJpeFswXSwgbGF5ZXJSZW5kZXJlcigpLT5w cm9qZWN0aW9uTWF0cml4KCkgKiB6b29tU2NhbGUgKiByZW5kZXJNYXRyaXgpOworICAgIH0gZWxz ZQorICAgICAgICB0b0dMTWF0cml4KCZnbE1hdHJpeFswXSwgbGF5ZXJSZW5kZXJlcigpLT5wcm9q ZWN0aW9uTWF0cml4KCkgKiByZW5kZXJNYXRyaXgpOworCiAgICAgR0xDKGNvbnRleHQsIGNvbnRl eHQtPnVuaWZvcm1NYXRyaXg0ZnYocHJvZ3JhbS0+dmVydGV4U2hhZGVyKCkubWF0cml4TG9jYXRp b24oKSwgZmFsc2UsICZnbE1hdHJpeFswXSwgMSkpOwogCiAgICAgR0xDKGNvbnRleHQsIGNvbnRl eHQtPnVuaWZvcm00Zihwcm9ncmFtLT5mcmFnbWVudFNoYWRlcigpLmNvbG9yTG9jYXRpb24oKSwg ZGVidWdCb3JkZXJDb2xvcigpLnJlZCgpIC8gMjU1LjAsIGRlYnVnQm9yZGVyQ29sb3IoKS5ncmVl bigpIC8gMjU1LjAsIGRlYnVnQm9yZGVyQ29sb3IoKS5ibHVlKCkgLyAyNTUuMCwgMSkpOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NM YXllclRyZWVIb3N0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKaW5kZXggMDU4NTA3ODEwMWJhODA3NmRhOGQ2OGRk MWM5NGEzYjIzMmRjNmE1Ny4uMDI4YmRkY2U5YTBmYzIzYjRhYzk1ZGUyMDNiZGUwYTE1OGIwMGY4 YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Y2MvQ0NMYXllclRyZWVIb3N0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCkBAIC0xMzksNiArMTM5LDEyIEBA IHZvaWQgQ0NMYXllclRyZWVIb3N0OjppbnZhbGlkYXRlUm9vdExheWVyUmVjdChjb25zdCBJbnRS ZWN0JiBkaXJ0eVJlY3QpCiAgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+aW52YWxpZGF0ZVJvb3RM YXllclJlY3QoZGlydHlSZWN0KTsKIH0KIAordm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnNldFRleHR1 cmVab29tKGNvbnN0IGRvdWJsZSB6b29tKQoreworICAgIGlmIChtX2xheWVyUmVuZGVyZXIpCisg ICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+c2V0VGV4dHVyZVpvb20oem9vbSk7Cit9CisKIHZvaWQg Q0NMYXllclRyZWVIb3N0OjpzZXROZWVkc0NvbW1pdEFuZFJlZHJhdygpCiB7CiAjaWYgVVNFKFRI UkVBREVEX0NPTVBPU0lUSU5HKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmggYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuaAppbmRleCAwZGMx NDc4Y2VmNzc5MjM4MzA0ZTgzMTRmZDE3MGJkOTNmN2FjZWFlLi5iY2QyOTU0ZDVlMGMxYTExZmE0 MTdiNGQ5OTk5NTZiMjlmYzk5MDRiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuaApAQCAt OTQsNiArOTQsNyBAQCBwdWJsaWM6CiAgICAgaW50IGZyYW1lTnVtYmVyKCkgY29uc3QgeyByZXR1 cm4gbV9mcmFtZU51bWJlcjsgfQogCiAgICAgdm9pZCBpbnZhbGlkYXRlUm9vdExheWVyUmVjdChj b25zdCBJbnRSZWN0JiBkaXJ0eVJlY3QpOworICAgIHZvaWQgc2V0VGV4dHVyZVpvb20oY29uc3Qg ZG91YmxlKTsKIAogICAgIHZvaWQgc2V0TmVlZHNDb21taXRBbmRSZWRyYXcoKTsKICAgICB2b2lk IHNldE5lZWRzUmVkcmF3KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IGE0NDNlMTMw ZGRjMmIwOTgxZWVmMjNjZGU3NDY5YTE2YTIwZDA5ZWUuLjFmNWFlZTU3NTY2OTI2NDI2YmE5NjUx OWM4YjE2MDAyMDE1MjNkYmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hh bmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTQgQEAKKzIwMTEtMDgtMTggIFcuIEphbWVzIE1hY0xlYW4gIDx3am1hY2xlYW5AY2hyb21pdW0u b3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gQWRkIGJhY2tlbmQgY29tcG9zaXRvciBzdXBwb3J0 IGZvciByZXNjYWxpbmcgKHpvb21pbmcpIHRleHR1cmVzIGR1cmluZyB6b29tIGFuaW1hdGlvbi4K KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY2NDcyCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBzcmMvV2Vi Vmlld0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6c2V0Wm9vbUxldmVs KToKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6OmludmFsaWRhdGVSb290TGF5ZXJSZWN0 KToKKwogMjAxMS0wOC0xNyAgQWRhbSBSb2JlbiAgPGFyb2JlbkBhcHBsZS5jb20+CiAKICAgICAg ICAgTWFrZSBXZWJDb3JlIGtlZXAgdHJhY2sgb2YgdGhlIGN1cnJlbnQgZGV2aWNlIHNjYWxlIGZh Y3RvcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwu Y3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4IDJi ZmJmNDdiNDFhYmM0Y2Q5YjlmMDQ3OGU3OTlmNmVmNWI1NjAxM2YuLjFlOWM3ZTQzNWM2NmMzZGQ5 ODMxNzliMTlkNDgwMjg2OGU3ZGY5OTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYlZpZXdJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJWaWV3SW1wbC5jcHAKQEAgLTE3ODksNiArMTc4OSw5IEBAIGRvdWJsZSBXZWJWaWV3SW1wbDo6 em9vbUxldmVsKCkKIAogZG91YmxlIFdlYlZpZXdJbXBsOjpzZXRab29tTGV2ZWwoYm9vbCB0ZXh0 T25seSwgZG91YmxlIHpvb21MZXZlbCkKIHsKKyAgICBpZiAobV9sYXllclRyZWVIb3N0KQorICAg ICAgICBtX2xheWVyVHJlZUhvc3QtPnNldFRleHR1cmVab29tKDEuMCk7CisKICAgICBpZiAoem9v bUxldmVsIDwgbV9taW5pbXVtWm9vbUxldmVsKQogICAgICAgICBtX3pvb21MZXZlbCA9IG1fbWlu aW11bVpvb21MZXZlbDsKICAgICBlbHNlIGlmICh6b29tTGV2ZWwgPiBtX21heGltdW1ab29tTGV2 ZWwpCkBAIC0yNTExLDYgKzI1MTQsNyBAQCB2b2lkIFdlYlZpZXdJbXBsOjppbnZhbGlkYXRlUm9v dExheWVyUmVjdChjb25zdCBJbnRSZWN0JiByZWN0KQogICAgIEZyYW1lVmlldyogdmlldyA9IHBh Z2UoKS0+bWFpbkZyYW1lKCktPnZpZXcoKTsKICAgICBJbnRSZWN0IGRpcnR5UmVjdCA9IHZpZXct PndpbmRvd1RvQ29udGVudHMocmVjdCk7CiAgICAgdXBkYXRlTGF5ZXJUcmVlVmlld3BvcnQoKTsK KyAgICBtX2xheWVyVHJlZUhvc3QtPnNldFRleHR1cmVab29tKDEuMCk7CiAgICAgbV9sYXllclRy ZWVIb3N0LT5pbnZhbGlkYXRlUm9vdExheWVyUmVjdChkaXJ0eVJlY3QpOwogICAgIHNldFJvb3RM YXllck5lZWRzRGlzcGxheSgpOwogfQo= 105804 2011-08-31 11:36:45 -0700 2011-09-06 12:49:35 -0700 Patch bug-66472-20110831143537.patch text/plain 19833 wjmaclean U3VidmVyc2lvbiBSZXZpc2lvbjogOTQyMDcKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBhMTJhYWE1NTE0MGZhYjQzMDI2YThl YjI0ZWRiYzRkNWJkNGZlZDAxLi5jODU4MWIyNmJjODg2ODExMjljZjEwYjJkMGRjNWI5NmYzYTY4 ZGVlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDgtMzEgIFcuIEphbWVzIE1hY0xlYW4g IDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gQWRkIGJhY2tl bmQgY29tcG9zaXRvciBzdXBwb3J0IGZvciByZXNjYWxpbmcgKHpvb21pbmcpIHRleHR1cmVzIGR1 cmluZyB6b29tIGFuaW1hdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTY2NDcyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS1ncHUtbGludXgvcGxhdGZvcm0vY2hyb21p dW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0LWV4cGVjdGVkLnBuZzogQWRk ZWQuCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0tZ3B1LWxpbnV4L3BsYXRmb3JtL2Nocm9t aXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC1leHBlY3RlZC50eHQ6IEFk ZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0 b3Itc2NhbGUtdGVzdC5odG1sOiBBZGRlZC4KKwogMjAxMS0wOC0zMSAgRGF2aWQgSHlhdHQgIDxo eWF0dEBhcHBsZS5jb20+CiAKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTY3MzAwCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1 bS1ncHUtbGludXgvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1z Y2FsZS10ZXN0LWV4cGVjdGVkLnBuZyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWdw dS1saW51eC9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFuaW1hdG9yLXNjYWxl LXRlc3QtZXhwZWN0ZWQucG5nCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjY4ZWIzZmYzMDBiNDE4NWJlYTQzOGY5MWNk ZWY0YmNlOTJkNWE4M2UKR0lUIGJpbmFyeSBwYXRjaApsaXRlcmFsIDI4NzEKemNtZUFTQE4/KG9s SHlgdVZCcSFpYTB5fnlVeyt2WVYyYT5pMCpaKT1oXmhsQSVAV3MkbEhgb2s8bX0/b1QhdGh8CnpH ZWIrJDxWMGcqXkYpZ0AoPTxhJV5KSFQpXk9XUXlpJlRyJFJPNVhRZT5YOE9hR21zWWFTVy1MXlkr Rjstb3ArOAp6aGFLVnt7RU5QNGE8R0NpZUhvSzI9aUhlKTg1K3soWnI8QXZ8MHs9fGZ1VGFXayhF SX1JRCZ6fWFGanVWSy1nR2EKemVjPHhCbntnbDMlelZxckBTKXlqR15BO3IrYHZKZXdvUk9ZQV4t VjdDV2ExOTlmcFAoMlN5cEFmaVJqOU1zdll2CnhFKks9YVZEOVQjWitSSVEpO302OHFldHJ9RVJ9 UkU7fEY3Jl5AJXhteFBkS1UyMldRJW12djRGTyNwQForU1VMNwoKbGl0ZXJhbCAwCkhjbVY/ZDAw MDAxCgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tZ3B1LWxpbnV4 L3BsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC1l eHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1ncHUtbGludXgvcGxh dGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0LWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi41ZjgxZDIxZTI3OWUxZWQ0YTU1NzQ3MGEwZjE3YTZjY2FkZjk3 ZWRkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tZ3B1 LWxpbnV4L3BsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUt dGVzdC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitsYXllciBhdCAoMCwwKSBzaXplIDgw MHg2MDAKKyAgUmVuZGVyVmlldyBhdCAoMCwwKSBzaXplIDgwMHg2MDAKK2xheWVyIGF0ICgwLDAp IHNpemUgODAweDYwMAorICBSZW5kZXJCbG9jayB7SFRNTH0gYXQgKDAsMCkgc2l6ZSA4MDB4NjAw CisgICAgUmVuZGVyQm9keSB7Qk9EWX0gYXQgKDgsOCkgc2l6ZSA3ODR4NTg0CitsYXllciBhdCAo MTAwLDEwMCkgc2l6ZSAxMDB4MTAwCisgIFJlbmRlckJsb2NrIChwb3NpdGlvbmVkKSB7RElWfSBh dCAoMTAwLDEwMCkgc2l6ZSAxMDB4MTAwIFtiZ2NvbG9yPSMwMDAwRkZdCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFuaW1hdG9yLXNj YWxlLXRlc3QuaHRtbCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5n L3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjYwZjcxN2M4ODY4ZWFk MTA1OWFmMGVjMzI0Mjg0NGFmZmZjNDBlZmUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFuaW1hdG9yLXNjYWxlLXRlc3Qu aHRtbApAQCAtMCwwICsxLDI0IEBACis8aHRtbD4KKyAgIDxoZWFkPgorICAgICA8c2NyaXB0Pgor ICAgICAgIGlmICh3aW5kb3cuaW50ZXJuYWxzKSB7CisgICAgICAgICB3aW5kb3cuaW50ZXJuYWxz LnNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKGRvY3VtZW50LCB0cnVlKTsKKyAgICAgICAgIHdpbmRv dy5pbnRlcm5hbHMuc2V0Wm9vbUFuaW1hdG9yU2NhbGUoZG9jdW1lbnQsIDAuOCk7CisgICAgICAg fQorICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICB3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworCisgICAgICAgZnVuY3Rp b24gZG9UZXN0KCkgeworICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImFCb3giKS5z dHlsZS5iYWNrZ3JvdW5kQ29sb3IgPSAiIzAwMDBGRiI7IC8vIENoYW5nZSB0byBibHVlCisKKyAg ICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgICAgd2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgIH0KKyAgICAg ICB9CisgICAgICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoImxvYWQiLCBkb1Rlc3QsIGZhbHNl KTsKKyAgICAgPC9zY3JpcHQ+CisgICA8L2hlYWQ+CisgPGJvZHk+CisgICAgPGRpdiBpZD0iYUJv eCIgc3R5bGU9IndpZHRoOjEwMHB4OyBoZWlnaHQ6MTAwcHg7IHBvc2l0aW9uOmFic29sdXRlOyBs ZWZ0OjEwMHB4OyB0b3A6MTAwcHg7IGJhY2tncm91bmQtY29sb3I6I0ZGMDAwMCI+PC9kaXY+Cisg PC9ib2R5PgorIDwvaHRtbD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBi L1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBlOTQ2NTU2YzMyMzQzMjZjYmM3MDg3ZjNl ZTEyYmMyMmYzNTk3NDQyLi5kMzgyNjVkY2M3NDA2MjUxYTBmZmFkYzJlNGY3NGE0YzUyYjVmZmRh IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAKKzIwMTEtMDgtMzEgIFcuIEphbWVzIE1hY0xl YW4gIDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gQWRkIGJh Y2tlbmQgY29tcG9zaXRvciBzdXBwb3J0IGZvciByZXNjYWxpbmcgKHpvb21pbmcpIHRleHR1cmVz IGR1cmluZyB6b29tIGFuaW1hdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTY2NDcyCisKKyAgICAgICAgVGhpcyBwYXRjaCBjb250YWlucyBwbHVt YmluZyBmcm9tIEludGVybmFscyB0byBXZWJWaWV3SW1wbCB0aGF0IGNhbiBiZSByZW1vdmVkCisg ICAgICAgIGF0IGEgbGF0ZXIgdGltZSB3aGVuIHRoZSB6b29tIGFuaW1hdG9yIGNvZGUgaXMgY29t cGxldGUuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg VGVzdDogcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10 ZXN0Lmh0bWwKKworICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6U2V0dGluZ3M6OlNldHRpbmdzKToKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6CisgICAg ICAgIChXZWJDb3JlOjpTZXR0aW5nczo6c2V0Wm9vbUFuaW1hdG9yU2NhbGUpOgorICAgICAgICAo V2ViQ29yZTo6U2V0dGluZ3M6Onpvb21BbmltYXRvclNjYWxlKToKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwOgorICAgICAgICAo V2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpMYXllclJlbmRlcmVyQ2hyb21pdW0pOgor ICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjp1cGRhdGVMYXllcnMpOgor ICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzSW50ZXJu YWwpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpzZXRU ZXh0dXJlWm9vbSk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06Omdl dFRleHR1cmVab29tKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9D Q0xheWVyVHJlZUhvc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q0NMYXllclRyZWVIb3N0Ojpz ZXRUZXh0dXJlWm9vbSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NMYXllclRyZWVIb3N0Lmg6CisgICAgICAgICogdGVzdGluZy9JbnRlcm5hbHMuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6SW50ZXJuYWxzOjpzZXRab29tQW5pbWF0b3JTY2FsZSk6CisgICAgICAg ICogdGVzdGluZy9JbnRlcm5hbHMuaDoKKyAgICAgICAgKiB0ZXN0aW5nL0ludGVybmFscy5pZGw6 CisKIDIwMTEtMDgtMzAgIE9saXZlciBIdW50ICA8b2xpdmVyQGFwcGxlLmNvbT4KIAogICAgICAg ICBBZGQgc3VwcG9ydCBmb3IgY2hlY2tlZCBhcml0aG1ldGljCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3Mu Y3BwCmluZGV4IDQ1MDA3YzMyZmZiNDExMmM3NGE0NmMzN2RiZDczMDQ2ZDY2OTJiMDQuLmQ5MTQ3 ZDQ0OGE3MGZhMjQwOGU4YTY4ZmQ5MTI1OWEwYTAzZWFhN2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGlu Z3MuY3BwCkBAIC0yMTYsNiArMjE2LDcgQEAgU2V0dGluZ3M6OlNldHRpbmdzKFBhZ2UqIHBhZ2Up CiAgICAgLCBtX21lZGlhUGxheWJhY2tBbGxvd3NJbmxpbmUodHJ1ZSkKICAgICAsIG1fcGFzc3dv cmRFY2hvRW5hYmxlZChmYWxzZSkKICAgICAsIG1fbG9hZHNJbWFnZXNBdXRvbWF0aWNhbGx5VGlt ZXIodGhpcywgJlNldHRpbmdzOjpsb2Fkc0ltYWdlc0F1dG9tYXRpY2FsbHlUaW1lckZpcmVkKQor ICAgICwgbV96b29tQW5pbWF0b3JTY2FsZSgxLjApCiB7CiAgICAgLy8gQSBGcmFtZSBtYXkgbm90 IGhhdmUgYmVlbiBjcmVhdGVkIHlldCwgc28gd2UgaW5pdGlhbGl6ZSB0aGUgQXRvbWljU3RyaW5n IAogICAgIC8vIGhhc2ggYmVmb3JlIHRyeWluZyB0byB1c2UgaXQuCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NldHRpbmdz LmgKaW5kZXggNTE1MTlhZDVhYTMwYmFmZDkzYzM4YTVhN2QzNWIxYzk0ZGVjYWYwZC4uYTliNGFj NTAxMTFlYmQ2YzU5NTkyM2NlYzhjODlhMGE0MTc3ODc0YSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGFnZS9TZXR0aW5ncy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3Mu aApAQCAtNDM3LDcgKzQzNywxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdm9p ZCBzZXRGb3JjZUNvbXBvc2l0aW5nTW9kZShib29sIGZsYWcpIHsgbV9mb3JjZUNvbXBvc2l0aW5n TW9kZSA9IGZsYWc7IH0KICAgICAgICAgYm9vbCBmb3JjZUNvbXBvc2l0aW5nTW9kZSgpIHsgcmV0 dXJuIG1fZm9yY2VDb21wb3NpdGluZ01vZGU7IH0KLSAgICAgICAgCisKKyAgICAgICAgdm9pZCBz ZXRab29tQW5pbWF0b3JTY2FsZShkb3VibGUgc2NhbGUpIHsgbV96b29tQW5pbWF0b3JTY2FsZSA9 IHNjYWxlOyB9CisgICAgICAgIGRvdWJsZSB6b29tQW5pbWF0b3JTY2FsZSgpIHsgcmV0dXJuIG1f em9vbUFuaW1hdG9yU2NhbGU7IH0KKwogICAgICAgICB2b2lkIHNldFNob3VsZEluamVjdFVzZXJT Y3JpcHRzSW5Jbml0aWFsRW1wdHlEb2N1bWVudChib29sIGZsYWcpIHsgbV9zaG91bGRJbmplY3RV c2VyU2NyaXB0c0luSW5pdGlhbEVtcHR5RG9jdW1lbnQgPSBmbGFnOyB9CiAgICAgICAgIGJvb2wg c2hvdWxkSW5qZWN0VXNlclNjcmlwdHNJbkluaXRpYWxFbXB0eURvY3VtZW50KCkgeyByZXR1cm4g bV9zaG91bGRJbmplY3RVc2VyU2NyaXB0c0luSW5pdGlhbEVtcHR5RG9jdW1lbnQ7IH0KIApAQCAt NTk2LDYgKzU5OSw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgc3RhdGljIGJvb2wg Z0FWRm91bmRhdGlvbkVuYWJsZWQ7CiAjZW5kaWYKIAorICAgICAgICBkb3VibGUgbV96b29tQW5p bWF0b3JTY2FsZTsKKwogI2lmIFVTRShTQUZBUklfVEhFTUUpCiAgICAgICAgIHN0YXRpYyBib29s IGdTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzOwogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0u Y3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5k ZXJlckNocm9taXVtLmNwcAppbmRleCA3MGEwNWRjYTA5MDEwYTZjYjU5ZmNmNWIxZGFlMzEwMmQ4 ZjZkZGZkLi40ZWRjY2Y0ZDEyZDQ2ODkzNTg5OGIxZWMyZDUyMGVhNTNkZGRjNTMyIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKQEAgLTQ2Nyw2ICs0NjcsNyBAQCBMYXll clJlbmRlcmVyQ2hyb21pdW06OkxheWVyUmVuZGVyZXJDaHJvbWl1bShDQ0xheWVyVHJlZUhvc3Qq IG93bmVyLAogICAgIDogbV9vd25lcihvd25lcikKICAgICAsIG1fY3VycmVudFJlbmRlclN1cmZh Y2UoMCkKICAgICAsIG1fb2Zmc2NyZWVuRnJhbWVidWZmZXJJZCgwKQorICAgICwgbV90ZXh0dXJl Wm9vbSgxLjApCiAgICAgLCBtX2NvbnRleHQoY29udGV4dCkKICAgICAsIG1fZGVmYXVsdFJlbmRl clN1cmZhY2UoMCkKIHsKQEAgLTYyMCwxMSArNjIxLDEzIEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNo cm9taXVtOjp1cGRhdGVMYXllcnMoTGF5ZXJDaHJvbWl1bSogcm9vdExheWVyKQogICAgIFJlbmRl clN1cmZhY2VDaHJvbWl1bSogcm9vdFJlbmRlclN1cmZhY2UgPSByb290TGF5ZXItPnJlbmRlclN1 cmZhY2UoKTsKICAgICByb290UmVuZGVyU3VyZmFjZS0+Y2xlYXJMYXllckxpc3QoKTsKIAotICAg IFRyYW5zZm9ybWF0aW9uTWF0cml4IGlkZW50aXR5TWF0cml4OworICAgIFRyYW5zZm9ybWF0aW9u TWF0cml4IHpvb21NYXRyaXg7CisgICAgaWYgKG1fdGV4dHVyZVpvb20gIT0gMS4wKQorICAgICAg ICB6b29tTWF0cml4LnNjYWxlM2QobV90ZXh0dXJlWm9vbSwgbV90ZXh0dXJlWm9vbSwgMS4wKTsK IAogICAgIHsKICAgICAgICAgVFJBQ0VfRVZFTlQoIkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6dXBk YXRlTGF5ZXJzOjpjYWxjRHJhd0V0YyIsIHRoaXMsIDApOwotICAgICAgICBjYWxjdWxhdGVEcmF3 VHJhbnNmb3Jtc0FuZFZpc2liaWxpdHk8TGF5ZXJDaHJvbWl1bSwgUmVuZGVyU3VyZmFjZUNocm9t aXVtLCB2b2lkKj4ocm9vdExheWVyLCByb290TGF5ZXIsIGlkZW50aXR5TWF0cml4LCBpZGVudGl0 eU1hdHJpeCwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCwgcm9vdFJlbmRlclN1cmZhY2UtPmxheWVy TGlzdCgpLCAwLCBtX21heFRleHR1cmVTaXplKTsKKyAgICAgICAgY2FsY3VsYXRlRHJhd1RyYW5z Zm9ybXNBbmRWaXNpYmlsaXR5PExheWVyQ2hyb21pdW0sIFJlbmRlclN1cmZhY2VDaHJvbWl1bSwg dm9pZCo+KHJvb3RMYXllciwgcm9vdExheWVyLCB6b29tTWF0cml4LCB6b29tTWF0cml4LCByZW5k ZXJTdXJmYWNlTGF5ZXJMaXN0LCByb290UmVuZGVyU3VyZmFjZS0+bGF5ZXJMaXN0KCksIDAsIG1f bWF4VGV4dHVyZVNpemUpOwogICAgIH0KIAogICAgIHBhaW50TGF5ZXJDb250ZW50cyhyZW5kZXJT dXJmYWNlTGF5ZXJMaXN0KTsKQEAgLTc0NCwxMyArNzQ3LDE1IEBAIHZvaWQgTGF5ZXJSZW5kZXJl ckNocm9taXVtOjpkcmF3TGF5ZXJzSW50ZXJuYWwoKQogICAgIENDTGF5ZXJMaXN0IHJlbmRlclN1 cmZhY2VMYXllckxpc3Q7CiAgICAgcmVuZGVyU3VyZmFjZUxheWVyTGlzdC5hcHBlbmQocm9vdERy YXdMYXllcik7CiAKLSAgICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCBpZGVudGl0eU1hdHJpeDsKKyAg ICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCB6b29tTWF0cml4OworICAgIGlmIChtX3RleHR1cmVab29t ICE9IDEuMCkKKyAgICAgICAgem9vbU1hdHJpeC5zY2FsZTNkKG1fdGV4dHVyZVpvb20sIG1fdGV4 dHVyZVpvb20sIDEuMCk7CiAgICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSA9IHJvb3REcmF3TGF5 ZXItPnJlbmRlclN1cmZhY2UoKTsKICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5jbGVhckxh eWVyTGlzdCgpOwogCiAgICAgewogICAgICAgICBUUkFDRV9FVkVOVCgiTGF5ZXJSZW5kZXJlckNo cm9taXVtOjpkcmF3TGF5ZXJzSW50ZXJuYWw6OmNhbGNEcmF3RXRjIiwgdGhpcywgMCk7Ci0gICAg ICAgIGNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zQW5kVmlzaWJpbGl0eTxDQ0xheWVySW1wbCwgQ0NS ZW5kZXJTdXJmYWNlLCBDQ0xheWVyU29ydGVyPihyb290RHJhd0xheWVyLCByb290RHJhd0xheWVy LCBpZGVudGl0eU1hdHJpeCwgaWRlbnRpdHlNYXRyaXgsIHJlbmRlclN1cmZhY2VMYXllckxpc3Qs IG1fZGVmYXVsdFJlbmRlclN1cmZhY2UtPmxheWVyTGlzdCgpLCAmbV9sYXllclNvcnRlciwgbV9t YXhUZXh0dXJlU2l6ZSk7CisgICAgICAgIGNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zQW5kVmlzaWJp bGl0eTxDQ0xheWVySW1wbCwgQ0NSZW5kZXJTdXJmYWNlLCBDQ0xheWVyU29ydGVyPihyb290RHJh d0xheWVyLCByb290RHJhd0xheWVyLCB6b29tTWF0cml4LCB6b29tTWF0cml4LCByZW5kZXJTdXJm YWNlTGF5ZXJMaXN0LCBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5sYXllckxpc3QoKSwgJm1fbGF5 ZXJTb3J0ZXIsIG1fbWF4VGV4dHVyZVNpemUpOwogICAgIH0KIAogICAgIC8vIFRoZSBHTCB2aWV3 cG9ydCBjb3ZlcnMgdGhlIGVudGlyZSB2aXNpYmxlIGFyZWEsIGluY2x1ZGluZyB0aGUgc2Nyb2xs YmFycy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggMmQ4MDQwM2RkNTI2 YmNlZWM4NGIzZTljYTRjODA5MjYxYWMxNzVmZC4uY2M4NDFhY2E2OWZhNmFiZDA0NmM4NDQyMzQ3 OGM3ZTZhZDEzMDE5OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKQEAgLTEw Nyw2ICsxMDcsOSBAQCBwdWJsaWM6CiAgICAgLy8gcHV0cyBiYWNrYnVmZmVyIG9uc2NyZWVuCiAg ICAgdm9pZCBwcmVzZW50KCk7CiAKKyAgICB2b2lkIHNldFRleHR1cmVab29tKGRvdWJsZSBmYWN0 b3IpIHsgbV90ZXh0dXJlWm9vbSA9IGZhY3RvcjsgfQorICAgIGRvdWJsZSBnZXRUZXh0dXJlWm9v bSgpIHsgcmV0dXJuIG1fdGV4dHVyZVpvb207IH0KKwogICAgIHVuc2lnbmVkIGNyZWF0ZUxheWVy VGV4dHVyZSgpOwogICAgIHZvaWQgZGVsZXRlTGF5ZXJUZXh0dXJlKHVuc2lnbmVkKTsKIApAQCAt MjAyLDYgKzIwNSw3IEBAIHByaXZhdGU6CiAKICAgICBDQ1JlbmRlclN1cmZhY2UqIG1fY3VycmVu dFJlbmRlclN1cmZhY2U7CiAgICAgdW5zaWduZWQgbV9vZmZzY3JlZW5GcmFtZWJ1ZmZlcklkOwor ICAgIGRvdWJsZSBtX3RleHR1cmVab29tOwogCiAgICAgLy8gTWF4aW11bSB0ZXh0dXJlIGRpbWVu c2lvbnMgc3VwcG9ydGVkLgogICAgIGludCBtX21heFRleHR1cmVTaXplOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVI b3N0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND TGF5ZXJUcmVlSG9zdC5jcHAKaW5kZXggNWQ2YmM5YzMyNzM1MjY3OWU1ODY0YWM4MmJlNWJiZjQ0 ZWU1MmU2Zi4uNGIyNTMxYWIyYmYzYThmNjQ1YWUxMGI2NDNjNjQyNTUxMjU4NjAwOSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXll clRyZWVIb3N0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCkBAIC0xNTMsNiArMTUzLDEyIEBAIHZvaWQgQ0NM YXllclRyZWVIb3N0OjppbnZhbGlkYXRlUm9vdExheWVyUmVjdChjb25zdCBJbnRSZWN0JiBkaXJ0 eVJlY3QpCiAgICAgbV9ub25Db21wb3NpdGVkQ29udGVudEhvc3QtPmludmFsaWRhdGVSZWN0KGRp cnR5UmVjdCk7CiB9CiAKK3ZvaWQgQ0NMYXllclRyZWVIb3N0OjpzZXRUZXh0dXJlWm9vbShjb25z dCBkb3VibGUgem9vbSkKK3sKKyAgICBpZiAobV9sYXllclJlbmRlcmVyKQorICAgICAgICBtX2xh eWVyUmVuZGVyZXItPnNldFRleHR1cmVab29tKHpvb20pOworfQorCiB2b2lkIENDTGF5ZXJUcmVl SG9zdDo6c2V0TmVlZHNDb21taXRBbmRSZWRyYXcoKQogewogI2lmIFVTRShUSFJFQURFRF9DT01Q T1NJVElORykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKaW5kZXggOTliOGJmMjA5NGQ4MzY0 MTQ4M2I0OWQ5M2M2OTBmYjFlYWJhZThjNi4uNzBkMDc0MGRkOGViODA0MTY5N2MzNmU2ZjRjY2Vj MGI4YmJkYWM4YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKQEAgLTEwMCw2ICsxMDAs NyBAQCBwdWJsaWM6CiAgICAgaW50IGZyYW1lTnVtYmVyKCkgY29uc3QgeyByZXR1cm4gbV9mcmFt ZU51bWJlcjsgfQogCiAgICAgdm9pZCBpbnZhbGlkYXRlUm9vdExheWVyUmVjdChjb25zdCBJbnRS ZWN0JiBkaXJ0eVJlY3QpOworICAgIHZvaWQgc2V0VGV4dHVyZVpvb20oY29uc3QgZG91YmxlKTsK IAogICAgIHZvaWQgc2V0TmVlZHNDb21taXRBbmRSZWRyYXcoKTsKICAgICB2b2lkIHNldE5lZWRz UmVkcmF3KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5j cHAgYi9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5jcHAKaW5kZXggZTQ0YjVmNzVl NjEyOTliOTU4OWIzMWFlNmYwNGY0MWZiNGFlMWM2MC4uMGRjMjcyM2VmZjNjOGIwNjA0ODRiNzlh MjNkNzFhNjU5NDE2NTAxNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRl cm5hbHMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmNwcApAQCAt MjQyLDYgKzI0MiwxNiBAQCB2b2lkIEludGVybmFsczo6c2V0Rm9yY2VDb21wb3NpdGluZ01vZGUo RG9jdW1lbnQqIGRvY3VtZW50LCBib29sIGVuYWJsZWQsIEV4Y2VwdAogICAgIGRvY3VtZW50LT5z ZXR0aW5ncygpLT5zZXRGb3JjZUNvbXBvc2l0aW5nTW9kZShlbmFibGVkKTsKIH0KIAordm9pZCBJ bnRlcm5hbHM6OnNldFpvb21BbmltYXRvclNjYWxlKERvY3VtZW50ICpkb2N1bWVudCwgZG91Ymxl IHNjYWxlLCBFeGNlcHRpb25Db2RlJiBlYykKK3sKKyAgICBpZiAoIWRvY3VtZW50IHx8ICFkb2N1 bWVudC0+c2V0dGluZ3MoKSkgeworICAgICAgICBlYyA9IElOVkFMSURfQUNDRVNTX0VSUjsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGRvY3VtZW50LT5zZXR0aW5ncygpLT5zZXRab29t QW5pbWF0b3JTY2FsZShzY2FsZSk7Cit9CisKIHZvaWQgSW50ZXJuYWxzOjpzZXRQYXNzd29yZEVj aG9FbmFibGVkKERvY3VtZW50KiBkb2N1bWVudCwgYm9vbCBlbmFibGVkLCBFeGNlcHRpb25Db2Rl JiBlYykKIHsKICAgICBpZiAoIWRvY3VtZW50IHx8ICFkb2N1bWVudC0+c2V0dGluZ3MoKSkgewpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRlcm5hbHMuaCBiL1NvdXJjZS9X ZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmgKaW5kZXggNTkyNDllM2YxZmFmN2ZjODU1YTFkZTk2 YWMzZDVmZmRkODg5Y2UzZS4uMGE1NGU2OTg2YWJmMDg5MjcxODg4MzE3YjgzZjkwYTk0MGIyMTEz YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRlcm5hbHMuaAorKysgYi9T b3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5oCkBAIC03Nyw2ICs3Nyw3IEBAIHB1Ymxp YzoKICAgICBQYXNzUmVmUHRyPFJhbmdlPiBtYXJrZXJSYW5nZUZvck5vZGUoTm9kZSosIHVuc2ln bmVkLCBFeGNlcHRpb25Db2RlJik7CiAKICAgICB2b2lkIHNldEZvcmNlQ29tcG9zaXRpbmdNb2Rl KERvY3VtZW50KiwgYm9vbCBlbmFibGVkLCBFeGNlcHRpb25Db2RlJik7CisgICAgdm9pZCBzZXRa b29tQW5pbWF0b3JTY2FsZShEb2N1bWVudCosIGRvdWJsZSBzY2FsZSwgRXhjZXB0aW9uQ29kZSYp OwogCiAgICAgdm9pZCBzZXRQYXNzd29yZEVjaG9FbmFibGVkKERvY3VtZW50KiwgYm9vbCBlbmFi bGVkLCBFeGNlcHRpb25Db2RlJik7CiAgICAgdm9pZCBzZXRQYXNzd29yZEVjaG9EdXJhdGlvbklu U2Vjb25kcyhEb2N1bWVudCosIGRvdWJsZSBkdXJhdGlvbkluU2Vjb25kcywgRXhjZXB0aW9uQ29k ZSYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRlcm5hbHMuaWRsIGIv U291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRlcm5hbHMuaWRsCmluZGV4IDJkZTNmYzRiMWU4ZjQw ZWI5ZGRkZDZhOWRhZDk3YzYxMjA0ZTJjNjQuLmJhNmI3ZjQ1MzVkOWNmNmYyMDZlNzFmMDBkYTdj MzFmZWNmNmM1ZDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxz LmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5pZGwKQEAgLTUxLDYg KzUxLDcgQEAgbW9kdWxlIHdpbmRvdyB7CiAgICAgICAgIFJhbmdlIG1hcmtlclJhbmdlRm9yTm9k ZShpbiBOb2RlIG5vZGUsIGluIHVuc2lnbmVkIGxvbmcgaW5kZXgpIHJhaXNlcyhET01FeGNlcHRp b24pOwogCiAgICAgICAgIHZvaWQgc2V0Rm9yY2VDb21wb3NpdGluZ01vZGUoaW4gRG9jdW1lbnQg ZG9jdW1lbnQsIGluIGJvb2xlYW4gZW5hYmxlZCkgcmFpc2VzKERPTUV4Y2VwdGlvbik7CisgICAg ICAgIHZvaWQgc2V0Wm9vbUFuaW1hdG9yU2NhbGUoaW4gRG9jdW1lbnQgZG9jdW1lbnQsIGluIGRv dWJsZSBzY2FsZSkgcmFpc2VzKERPTUV4Y2VwdGlvbik7CiAKICAgICAgICAgdm9pZCBzZXRQYXNz d29yZEVjaG9FbmFibGVkKGluIERvY3VtZW50IGRvY3VtZW50LCBpbiBib29sZWFuIGVuYWJsZWQp IHJhaXNlcyhET01FeGNlcHRpb24pOwogICAgICAgICB2b2lkIHNldFBhc3N3b3JkRWNob0R1cmF0 aW9uSW5TZWNvbmRzKGluIERvY3VtZW50IGRvY3VtZW50LCBpbiBkb3VibGUgZHVyYXRpb25JblNl Y29uZHMpIHJhaXNlcyhET01FeGNlcHRpb24pOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRl eCBkOTNlZmViYjM3YTZlZWFmMjlkODQzM2E3YmNhZTlhNjIyMWRmZTczLi44OWRjZDZhMTgzNGI0 OWY2Yjg1NGYyZDM2NTRlZDRjYzAyNGFlNDA4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDIxIEBACisyMDExLTA4LTMxICBXLiBKYW1lcyBNYWNMZWFuICA8d2ptYWNsZWFu QGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIEFkZCBiYWNrZW5kIGNvbXBvc2l0 b3Igc3VwcG9ydCBmb3IgcmVzY2FsaW5nICh6b29taW5nKSB0ZXh0dXJlcyBkdXJpbmcgem9vbSBh bmltYXRpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD02NjQ3MgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg ICogcHVibGljL1dlYlNldHRpbmdzLmg6CisgICAgICAgICogc3JjL1dlYlNldHRpbmdzSW1wbC5j cHA6CisgICAgICAgIChXZWJLaXQ6OldlYlNldHRpbmdzSW1wbDo6V2ViU2V0dGluZ3NJbXBsKToK KyAgICAgICAgKFdlYktpdDo6V2ViU2V0dGluZ3NJbXBsOjpzZXRab29tQW5pbWF0b3JTY2FsZSk6 CisgICAgICAgICogc3JjL1dlYlNldHRpbmdzSW1wbC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJT ZXR0aW5nc0ltcGw6OmdldFpvb21BbmltYXRvclNjYWxlKToKKyAgICAgICAgKiBzcmMvV2ViVmll d0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6c2V0Wm9vbUxldmVsKToK KyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6OnNldFJvb3RMYXllck5lZWRzRGlzcGxheSk6 CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBsOjpzY2hlZHVsZUNvbXBvc2l0ZSk6CisKIDIw MTEtMDgtMzEgIE5hdCBEdWNhICA8bmR1Y2FAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFtDaHJv bWl1bV0gVW5yZXZpZXdlZCwgZml4IGluY29uc2lzdGVudCBXZWJLaXQuZ3lwaSBhZnRlciByOTQx MDYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlNldHRpbmdz LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJTZXR0aW5ncy5oCmluZGV4IDA0 NGQwNjE4Nzc0ZmVmNDE4NTNjNmIwMWMyMjhlNzY4MDNlY2MzODUuLjg2YWFlZjM5MDg1NzQ4ODRh N2FiMWU1MjUzOTZkYmYzNGJjYzVlYTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYlNldHRpbmdzLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJs aWMvV2ViU2V0dGluZ3MuaApAQCAtMTA0LDYgKzEwNCw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFs IHZvaWQgc2V0RWRpdGluZ0JlaGF2aW9yKEVkaXRpbmdCZWhhdmlvcikgPSAwOwogICAgIHZpcnR1 YWwgdm9pZCBzZXRBY2NlbGVyYXRlZENvbXBvc2l0aW5nRW5hYmxlZChib29sKSA9IDA7CiAgICAg dmlydHVhbCB2b2lkIHNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKGJvb2wpID0gMDsKKyAgICB2aXJ0 dWFsIHZvaWQgc2V0Wm9vbUFuaW1hdG9yU2NhbGUoZG91YmxlKSA9IDA7CisgICAgdmlydHVhbCBk b3VibGUgZ2V0Wm9vbUFuaW1hdG9yU2NhbGUoKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHNldENv bXBvc2l0ZVRvVGV4dHVyZUVuYWJsZWQoYm9vbCkgPSAwOwogICAgIHZpcnR1YWwgYm9vbCBjb21w b3NpdGVUb1RleHR1cmVFbmFibGVkKCkgY29uc3QgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBzZXRB Y2NlbGVyYXRlZENvbXBvc2l0aW5nRm9yM0RUcmFuc2Zvcm1zRW5hYmxlZChib29sKSA9IDA7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3Bw IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcAppbmRleCBi NDYzNDAxOTFlMmZiNjEyZDZjZjMzY2FkNjc5NjZkM2IwZDIzNGVjLi5hYmM1MjE4YzBhMWQyZjdj Y2Y1MjMwMWIyNTgzZWViNmM2N2RhNWJhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYlNldHRpbmdzSW1wbC5jcHAKQEAgLTUwLDYgKzUwLDcgQEAgV2ViU2V0dGluZ3NJbXBs OjpXZWJTZXR0aW5nc0ltcGwoU2V0dGluZ3MqIHNldHRpbmdzKQogICAgICwgbV9jb21wb3NpdGVU b1RleHR1cmVFbmFibGVkKGZhbHNlKQogICAgICwgbV9zaG93RlBTQ291bnRlcihmYWxzZSkKICAg ICAsIG1fc2hvd1BsYXRmb3JtTGF5ZXJUcmVlKGZhbHNlKQorICAgICwgbV96b29tQW5pbWF0b3JT Y2FsZSgxLjApCiB7CiAgICAgQVNTRVJUKHNldHRpbmdzKTsKIH0KQEAgLTMxOCw2ICszMTksMTIg QEAgdm9pZCBXZWJTZXR0aW5nc0ltcGw6OnNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKGJvb2wgZW5h YmxlZCkKICAgICBtX3NldHRpbmdzLT5zZXRGb3JjZUNvbXBvc2l0aW5nTW9kZShlbmFibGVkKTsK IH0KIAordm9pZCBXZWJTZXR0aW5nc0ltcGw6OnNldFpvb21BbmltYXRvclNjYWxlKGRvdWJsZSBz Y2FsZSkKK3sKKyAgICBpZiAoc2NhbGUgPiAwLjApCisgICAgICAgIG1fem9vbUFuaW1hdG9yU2Nh bGUgPSBzY2FsZTsKK30KKwogdm9pZCBXZWJTZXR0aW5nc0ltcGw6OnNldENvbXBvc2l0ZVRvVGV4 dHVyZUVuYWJsZWQoYm9vbCBlbmFibGVkKQogewogICAgIG1fY29tcG9zaXRlVG9UZXh0dXJlRW5h YmxlZCA9IGVuYWJsZWQ7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJTZXR0aW5nc0ltcGwuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdz SW1wbC5oCmluZGV4IDE5MDY5OTVkYjc5NTExOTk0MWJhMTkxYzZlNTYyMGRiMDUxOWFkZDAuLjc2 MDU5NDZhZDA4ZGYyMzNmNjUzMTBmMDBkOGVlMzExMDcyNTRjZmYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5oCisrKyBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5oCkBAIC05Niw2ICs5Niw4IEBAIHB1Ymxp YzoKICAgICB2aXJ0dWFsIHZvaWQgc2V0RWRpdGluZ0JlaGF2aW9yKEVkaXRpbmdCZWhhdmlvcik7 CiAgICAgdmlydHVhbCB2b2lkIHNldEFjY2VsZXJhdGVkQ29tcG9zaXRpbmdFbmFibGVkKGJvb2wp OwogICAgIHZpcnR1YWwgdm9pZCBzZXRGb3JjZUNvbXBvc2l0aW5nTW9kZShib29sKTsKKyAgICB2 aXJ0dWFsIHZvaWQgc2V0Wm9vbUFuaW1hdG9yU2NhbGUoZG91YmxlKTsKKyAgICB2aXJ0dWFsIGRv dWJsZSBnZXRab29tQW5pbWF0b3JTY2FsZSgpIHsgcmV0dXJuIG1fem9vbUFuaW1hdG9yU2NhbGU7 IH0KICAgICB2aXJ0dWFsIHZvaWQgc2V0Q29tcG9zaXRlVG9UZXh0dXJlRW5hYmxlZChib29sKTsK ICAgICB2aXJ0dWFsIGJvb2wgY29tcG9zaXRlVG9UZXh0dXJlRW5hYmxlZCgpIGNvbnN0IHsgcmV0 dXJuIG1fY29tcG9zaXRlVG9UZXh0dXJlRW5hYmxlZDsgfQogICAgIHZpcnR1YWwgdm9pZCBzZXRB Y2NlbGVyYXRlZENvbXBvc2l0aW5nRm9yM0RUcmFuc2Zvcm1zRW5hYmxlZChib29sKTsKQEAgLTEy Niw2ICsxMjgsOCBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9jb21wb3NpdGVUb1RleHR1cmVFbmFi bGVkOwogICAgIGJvb2wgbV9zaG93RlBTQ291bnRlcjsKICAgICBib29sIG1fc2hvd1BsYXRmb3Jt TGF5ZXJUcmVlOworCisgICAgZG91YmxlIG1fem9vbUFuaW1hdG9yU2NhbGU7CiB9OwogCiB9IC8v IG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYlZpZXdJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBs LmNwcAppbmRleCA3ZjI4YmY4MmI0M2Y5ODJmNzhkY2IxMWIzMjE1NTljYjAyY2FhYTI2Li4yN2U4 NGE2NmNjYmM0MTYzNmJhMzQwNGViNzM4NjYwNmVkY2IxNGMwIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCkBAIC0xNzg2LDYgKzE3ODYsOSBAQCBkb3VibGUg V2ViVmlld0ltcGw6Onpvb21MZXZlbCgpCiAKIGRvdWJsZSBXZWJWaWV3SW1wbDo6c2V0Wm9vbUxl dmVsKGJvb2wgdGV4dE9ubHksIGRvdWJsZSB6b29tTGV2ZWwpCiB7CisgICAgaWYgKG1fbGF5ZXJU cmVlSG9zdCkKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRUZXh0dXJlWm9vbSgxLjApOwor CiAgICAgaWYgKHpvb21MZXZlbCA8IG1fbWluaW11bVpvb21MZXZlbCkKICAgICAgICAgbV96b29t TGV2ZWwgPSBtX21pbmltdW1ab29tTGV2ZWw7CiAgICAgZWxzZSBpZiAoem9vbUxldmVsID4gbV9t YXhpbXVtWm9vbUxldmVsKQpAQCAtMjUyOSw5ICsyNTMyLDEzIEBAIHZvaWQgV2ViVmlld0ltcGw6 OnNldFJvb3RHcmFwaGljc0xheWVyKEdyYXBoaWNzTGF5ZXIqIGxheWVyKQogdm9pZCBXZWJWaWV3 SW1wbDo6c2V0Um9vdExheWVyTmVlZHNEaXNwbGF5KCkKIHsKICNpZiBVU0UoVEhSRUFERURfQ09N UE9TSVRJTkcpCi0gICAgaWYgKG1fbGF5ZXJUcmVlSG9zdCkKKyAgICBpZiAobV9sYXllclRyZWVI b3N0KSB7CisgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+c2V0VGV4dHVyZVpvb20obV9wYWdlLT5z ZXR0aW5ncygpLT56b29tQW5pbWF0b3JTY2FsZSgpKTsKICAgICAgICAgbV9sYXllclRyZWVIb3N0 LT5zZXROZWVkc0NvbW1pdEFuZFJlZHJhdygpOworICAgIH0KICNlbHNlCisgICAgaWYgKG1fbGF5 ZXJUcmVlSG9zdCkKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRUZXh0dXJlWm9vbShtX3Bh Z2UtPnNldHRpbmdzKCktPnpvb21BbmltYXRvclNjYWxlKCkpOwogICAgIG1fY2xpZW50LT5zY2hl ZHVsZUNvbXBvc2l0ZSgpOwogI2VuZGlmCiB9CkBAIC0yNjczLDYgKzI2ODAsOCBAQCB2b2lkIFdl YlZpZXdJbXBsOjpkaWRSZWNyZWF0ZUdyYXBoaWNzQ29udGV4dChib29sIHN1Y2Nlc3MpCiAjaWYg IVVTRShUSFJFQURFRF9DT01QT1NJVElORykKIHZvaWQgV2ViVmlld0ltcGw6OnNjaGVkdWxlQ29t cG9zaXRlKCkKIHsKKyAgICBBU1NFUlQobV9sYXllclRyZWVIb3N0KTsKKyAgICBtX2xheWVyVHJl ZUhvc3QtPnNldFRleHR1cmVab29tKG1fcGFnZS0+c2V0dGluZ3MoKS0+em9vbUFuaW1hdG9yU2Nh bGUoKSk7CiAgICAgbV9jbGllbnQtPnNjaGVkdWxlQ29tcG9zaXRlKCk7CiB9CiAjZW5kaWYK 106470 2011-09-06 12:49:40 -0700 2011-09-07 08:37:44 -0700 Patch bug-66472-20110906154733.patch text/plain 26743 wjmaclean U3VidmVyc2lvbiBSZXZpc2lvbjogOTQ1NzYKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBhZWJlMzYwYzMxM2JiZGJlNjg3YzZm ZjQyNzZmZDIyZjYxNmM3NzNmLi4zZDg1Y2IwODNhNWQxMWMxMGQwYjA3NGQ5YzVjMjRjYmExYzEz ODMzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTEtMDktMDYgIFcuIEphbWVzIE1hY0xlYW4g IDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gQWRkIGJhY2tl bmQgY29tcG9zaXRvciBzdXBwb3J0IGZvciByZXNjYWxpbmcgKHpvb21pbmcpIHRleHR1cmVzIGR1 cmluZyB6b29tIGFuaW1hdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTY2NDcyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS1ncHUtbGludXgvcGxhdGZvcm0vY2hyb21p dW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0LWV4cGVjdGVkLnBuZzogQWRk ZWQuCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0tZ3B1LWxpbnV4L3BsYXRmb3JtL2Nocm9t aXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC1leHBlY3RlZC50eHQ6IEFk ZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtLWdwdS1saW51eC9wbGF0Zm9ybS9jaHJv bWl1bS9jb21wb3NpdGluZy96b29tLWFuaW1hdG9yLXNjYWxlLXRlc3QyLWV4cGVjdGVkLnBuZzog QWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0tZ3B1LWxpbnV4L3BsYXRmb3JtL2No cm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdDItZXhwZWN0ZWQudHh0 OiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFu aW1hdG9yLXNjYWxlLXRlc3QuaHRtbDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vY2hyb21p dW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0Mi5odG1sOiBBZGRlZC4KKyAg ICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQ6CisKIDIwMTEt MDktMDYgIFBoaWxpcHBlIE5vcm1hbmQgIDxwbm9ybWFuZEBpZ2FsaWEuY29tPgogCiAgICAgICAg IFVucmV2aWV3ZWQsIHVuc2tpcCB0ZXN0cyBub3cgcGFzc2luZyBiZWNhdXNlIGJ1ZyA2MTUyMyB3 YXMgZml4ZWQuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1ncHUt bGludXgvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10 ZXN0LWV4cGVjdGVkLnBuZyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWdwdS1saW51 eC9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFuaW1hdG9yLXNjYWxlLXRlc3Qt ZXhwZWN0ZWQucG5nCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjY4ZWIzZmYzMDBiNDE4NWJlYTQzOGY5MWNkZWY0YmNl OTJkNWE4M2UKR0lUIGJpbmFyeSBwYXRjaApsaXRlcmFsIDI4NzEKemNtZUFTQE4/KG9sSHlgdVZC cSFpYTB5fnlVeyt2WVYyYT5pMCpaKT1oXmhsQSVAV3MkbEhgb2s8bX0/b1QhdGh8CnpHZWIrJDxW MGcqXkYpZ0AoPTxhJV5KSFQpXk9XUXlpJlRyJFJPNVhRZT5YOE9hR21zWWFTVy1MXlkrRjstb3Ar OAp6aGFLVnt7RU5QNGE8R0NpZUhvSzI9aUhlKTg1K3soWnI8QXZ8MHs9fGZ1VGFXayhFSX1JRCZ6 fWFGanVWSy1nR2EKemVjPHhCbntnbDMlelZxckBTKXlqR15BO3IrYHZKZXdvUk9ZQV4tVjdDV2Ex OTlmcFAoMlN5cEFmaVJqOU1zdll2CnhFKks9YVZEOVQjWitSSVEpO302OHFldHJ9RVJ9UkU7fEY3 Jl5AJXhteFBkS1UyMldRJW12djRGTyNwQForU1VMNwoKbGl0ZXJhbCAwCkhjbVY/ZDAwMDAxCgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tZ3B1LWxpbnV4L3BsYXRm b3JtL2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC1leHBlY3Rl ZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1ncHUtbGludXgvcGxhdGZvcm0v Y2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0LWV4cGVjdGVkLnR4 dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi41ZjgxZDIxZTI3OWUxZWQ0YTU1NzQ3MGEwZjE3YTZjY2FkZjk3ZWRkCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tZ3B1LWxpbnV4 L3BsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC1l eHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitsYXllciBhdCAoMCwwKSBzaXplIDgwMHg2MDAK KyAgUmVuZGVyVmlldyBhdCAoMCwwKSBzaXplIDgwMHg2MDAKK2xheWVyIGF0ICgwLDApIHNpemUg ODAweDYwMAorICBSZW5kZXJCbG9jayB7SFRNTH0gYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCisgICAg UmVuZGVyQm9keSB7Qk9EWX0gYXQgKDgsOCkgc2l6ZSA3ODR4NTg0CitsYXllciBhdCAoMTAwLDEw MCkgc2l6ZSAxMDB4MTAwCisgIFJlbmRlckJsb2NrIChwb3NpdGlvbmVkKSB7RElWfSBhdCAoMTAw LDEwMCkgc2l6ZSAxMDB4MTAwIFtiZ2NvbG9yPSMwMDAwRkZdCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1ncHUtbGludXgvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9z aXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0Mi1leHBlY3RlZC5wbmcgYi9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9jaHJvbWl1bS1ncHUtbGludXgvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRp bmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0Mi1leHBlY3RlZC5wbmcKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDE0 MjI2M2FkNDdiN2JhMzZkMjc2ZDJhY2U1NjA2YjljMGVmZjkxMwpHSVQgYmluYXJ5IHBhdGNoCmxp dGVyYWwgMjg2MQp6Y21lQVNATj8ob2xIeWB1VkJxIWlhMHl+eVV7K3ZZVjJhPmkwKlopPWheaGxB JUBXcyRsSGBvazxtfT9vVG19UDYKenF0cH13Z1QmTlNiQSFZcjxDTWd0V0NQMVlnT3RRWDFCKWJN Qk9feV91ZWw1aVQ+Q3Y7OTc4SlJ5dUVSZGxpNSojCnojYz0pM0tmIVk5ZnlXIWR5QjVyTW9qPnlA MUgqLSVkSGY2dktnXmw5ODVHbnVGZmImSUdEWlVkVXJQOXYhQHVLLQp6PCEkYkRDWSQjJUcrMC1S cmtULTxMdioxNVBDUkc2Rik9KGFtRDZFcG1+bnVLcEBWYWpGJllTP0RQYzRoak9LI1QKZlQhNVNs WnR4I28kLU8/V2l9d187e21iQyM+Z1RlfkRXTTRmV05FN0cKCmxpdGVyYWwgMApIY21WP2QwMDAw MQoKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWdwdS1saW51eC9w bGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFuaW1hdG9yLXNjYWxlLXRlc3QyLWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWdwdS1saW51eC9wbGF0 Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFuaW1hdG9yLXNjYWxlLXRlc3QyLWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi44YjEzNzg5MTc5MWZlOTY5MjdhZDc4ZTY0YjBhYWQ3YmRlZDA4 YmRjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tZ3B1 LWxpbnV4L3BsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUt dGVzdDItZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0 Lmh0bWwgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFu aW1hdG9yLXNjYWxlLXRlc3QuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42MGY3MTdjODg2OGVhZDEwNTlhZjBl YzMyNDI4NDRhZmZmYzQwZWZlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZv cm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0Lmh0bWwKQEAg LTAsMCArMSwyNCBAQAorPGh0bWw+CisgICA8aGVhZD4KKyAgICAgPHNjcmlwdD4KKyAgICAgICBp ZiAod2luZG93LmludGVybmFscykgeworICAgICAgICAgd2luZG93LmludGVybmFscy5zZXRGb3Jj ZUNvbXBvc2l0aW5nTW9kZShkb2N1bWVudCwgdHJ1ZSk7CisgICAgICAgICB3aW5kb3cuaW50ZXJu YWxzLnNldFpvb21BbmltYXRvclNjYWxlKGRvY3VtZW50LCAwLjgpOworICAgICAgIH0KKyAgICAg ICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgd2luZG93LmxheW91 dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKworICAgICAgIGZ1bmN0aW9uIGRvVGVz dCgpIHsKKyAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJhQm94Iikuc3R5bGUuYmFj a2dyb3VuZENvbG9yID0gIiMwMDAwRkYiOyAvLyBDaGFuZ2UgdG8gYmx1ZQorCisgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgICAgIHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgICB9CisgICAgICAgfQorICAg ICAgIHdpbmRvdy5hZGRFdmVudExpc3RlbmVyKCJsb2FkIiwgZG9UZXN0LCBmYWxzZSk7CisgICAg IDwvc2NyaXB0PgorICAgPC9oZWFkPgorIDxib2R5PgorICAgIDxkaXYgaWQ9ImFCb3giIHN0eWxl PSJ3aWR0aDoxMDBweDsgaGVpZ2h0OjEwMHB4OyBwb3NpdGlvbjphYnNvbHV0ZTsgbGVmdDoxMDBw eDsgdG9wOjEwMHB4OyBiYWNrZ3JvdW5kLWNvbG9yOiNGRjAwMDAiPjwvZGl2PgorIDwvYm9keT4K KyA8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9jb21w b3NpdGluZy96b29tLWFuaW1hdG9yLXNjYWxlLXRlc3QyLmh0bWwgYi9MYXlvdXRUZXN0cy9wbGF0 Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFuaW1hdG9yLXNjYWxlLXRlc3QyLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uNmNkZTFlY2UzNzNmZTJhYWZmY2U0ZWQ1MDVlNjkyOWRjODdlNWM3NgotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5n L3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdDIuaHRtbApAQCAtMCwwICsxLDI3IEBACis8aHRtbD4K KyAgIDxoZWFkPgorICAgICA8c2NyaXB0PgorICAgICAgIGlmICh3aW5kb3cuaW50ZXJuYWxzKSB7 CisgICAgICAgICB3aW5kb3cuaW50ZXJuYWxzLnNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKGRvY3Vt ZW50LCB0cnVlKTsKKyAgICAgICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0Wm9vbUFuaW1hdG9yU2Nh bGUoZG9jdW1lbnQsIDEuMjUpOworICAgICAgIH0KKyAgICAgICBpZiAod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKQorICAgICAgICAgd2luZG93LmxheW91dFRlc3RDb250cm9sbGVyLndhaXRV bnRpbERvbmUoKTsKKworICAgICAgIGZ1bmN0aW9uIGRvVGVzdCgpIHsKKyAgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJhQm94Iikuc3R5bGUuYmFja2dyb3VuZENvbG9yID0gIiMwMDAw RkYiOyAvLyBDaGFuZ2UgdG8gYmx1ZQorCisgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKSB7CisgICAgICAgICAgIHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KHRydWUpOworICAgICAgICAgICB3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIubm90 aWZ5RG9uZSgpOworICAgICAgICAgfQorICAgICAgIH0KKyAgICAgICB3aW5kb3cuYWRkRXZlbnRM aXN0ZW5lcigibG9hZCIsIGRvVGVzdCwgZmFsc2UpOworICAgICA8L3NjcmlwdD4KKyAgIDwvaGVh ZD4KKyA8Ym9keT4KKyAgICA8IS0tICAgIElmIHN1Y2Nlc3NmdWwsIHRoZSBibHVlIGJveCBzaG91 bGQgZW5sYXJnZSB0byBiZSAxMjV4MTI1IGF0ICgxMjUsMTI1KS4KKyAgICAgIC0tPgorICAgIDxk aXYgaWQ9ImFCb3giIHN0eWxlPSJ3aWR0aDoxMDBweDsgaGVpZ2h0OjEwMHB4OyBwb3NpdGlvbjph YnNvbHV0ZTsgbGVmdDoxMDBweDsgdG9wOjEwMHB4OyBiYWNrZ3JvdW5kLWNvbG9yOiNGRjAwMDAi PjwvZGl2PgorIDwvYm9keT4KKyA8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0 Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5kZXggMzk1YzYyZTEyZjA0MDg2Mzli OTgyY2FiZDVkN2JiMjA2YWNjOGIyZi4uNTFkNjc4NGRlMDhiMWMyNmZmMzk4OGY4YzA2OGRjNGJj ZWQyOTI1MyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vdGVzdF9l eHBlY3RhdGlvbnMudHh0CisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL3Rlc3Rf ZXhwZWN0YXRpb25zLnR4dApAQCAtMjU4NSw2ICsyNTg1LDEwIEBAIEJVR1dLNDc5NDkgTUFDIEdQ VSA6IGNvbXBvc2l0aW5nL3JlZmxlY3Rpb25zL3JlZmxlY3Rpb24tb3BhY2l0eS5odG1sID0gSU1B R0UKIEJVR1dLNTQzMDYgR1BVIDogY29tcG9zaXRpbmcvcmVmbGVjdGlvbnMvYW5pbWF0aW9uLWlu c2lkZS1yZWZsZWN0aW9uLmh0bWwgPSBQQVNTIElNQUdFIElNQUdFK1RFWFQKIEJVR1dLNTQzMDYg R1BVIDogY29tcG9zaXRpbmcvcmVmbGVjdGlvbnMvbmVzdGVkLXJlZmxlY3Rpb24tYW5pbWF0ZWQu aHRtbCA9IFBBU1MgSU1BR0UKIAorLy8gVGhpcyBpcyBhIHRlbXBvcmFyeSB0ZXN0IHRoYXQgcmVs aWVzIG9uIHRoZSBkZWJ1Zy1jbGVhciBjb2xvdXIsIHNvIGRvbid0IGJvdGhlcgorLy8gaW4gcmVs ZWFzZSBtb2RlLgorV09OVEZJWCBTS0lQIEdQVSBSRUxFQVNFIDogcGxhdGZvcm0vY2hyb21pdW0v Y29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0Lmh0bWwgPSBJTUFHRQorCiAvLyBU aGVzZSB0ZXN0cyBhcmUgdG9vIHNsb3cgd2l0aCBvdXIgTUVTQSBiYWNrZW5kLiAgV2UgY2FuIHJl LWVuYWJsZSB3aGVuIHdlIGhhdmUKIC8vIGJvdHMgcnVubmluZyB0ZXN0cyBvbiByZWFsIGhhcmR3 YXJlLgogQlVHV0s0OTYyOSBTS0lQIEdQVSA6IHBsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5n L2xvdHMtb2YtaW1nLWxheWVycy5odG1sID0gUEFTUwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGQ5ZmFiMGI4Y2Q3 YjMyYmQ0MjI4NDgxMjk3NmM4ZWVlZjIwYTg3MWUuLjE0NDI3NDdiY2FkZWJkYzlhYzg1ODg3NDJj MzQ1ODUwODMzY2Q1NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NCBAQAorMjAxMS0wOS0wNiAg Vy4gSmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2No cm9taXVtXSBBZGQgYmFja2VuZCBjb21wb3NpdG9yIHN1cHBvcnQgZm9yIHJlc2NhbGluZyAoem9v bWluZykgdGV4dHVyZXMgZHVyaW5nIHpvb20gYW5pbWF0aW9uLgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjY0NzIKKworICAgICAgICBUaGlzIHBhdGNo IGNvbnRhaW5zIHBsdW1iaW5nIGZyb20gSW50ZXJuYWxzIHRvIFdlYlZpZXdJbXBsIHRoYXQgY2Fu IGJlIHJlbW92ZWQKKyAgICAgICAgYXQgYSBsYXRlciB0aW1lIHdoZW4gdGhlIHpvb20gYW5pbWF0 b3IgY29kZSBpcyBjb21wbGV0ZS4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBUZXN0czogcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1h bmltYXRvci1zY2FsZS10ZXN0Lmh0bWwKKyAgICAgICAgICAgICAgIHBsYXRmb3JtL2Nocm9taXVt L2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdDIuaHRtbAorCisgICAgICAgICog cGFnZS9TZXR0aW5ncy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTZXR0aW5nczo6U2V0dGluZ3Mp OgorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNldHRpbmdz OjpzZXRab29tQW5pbWF0b3JTY2FsZSk6CisgICAgICAgIChXZWJDb3JlOjpTZXR0aW5nczo6em9v bUFuaW1hdG9yU2NhbGUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xh eWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVy Q2hyb21pdW06OkxheWVyUmVuZGVyZXJDaHJvbWl1bSk6CisgICAgICAgIChXZWJDb3JlOjpMYXll clJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnNJbnRlcm5hbCk6CisgICAgICAgICogcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmg6CisgICAgICAgIChX ZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OnNldFRleHR1cmVab29tKToKKyAgICAgICAg KFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6Z2V0VGV4dHVyZVpvb20pOgorICAgICAg ICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OkNDTGF5ZXJUcmVlSG9zdCk6CisgICAg ICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OmNvbW1pdFRvKToKKyAgICAgICAgKFdlYkNv cmU6OkNDTGF5ZXJUcmVlSG9zdDo6c2V0VGV4dHVyZVpvb20pOgorICAgICAgICAoV2ViQ29yZTo6 Q0NMYXllclRyZWVIb3N0Ojp1cGRhdGVMYXllcnMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oOgorICAgICAgICAoV2ViQ29yZTo6Q0NM YXllclRyZWVIb3N0Ojp0ZXh0dXJlWm9vbSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0SW1wbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpD Q0xheWVyVHJlZUhvc3RJbXBsOjpDQ0xheWVyVHJlZUhvc3RJbXBsKToKKyAgICAgICAgKFdlYkNv cmU6OkNDTGF5ZXJUcmVlSG9zdEltcGw6OnNldFRleHR1cmVab29tKToKKyAgICAgICAgKiBwbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3RJbXBsLmg6CisgICAgICAg IChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3RJbXBsOjp0ZXh0dXJlWm9vbSk6CisgICAgICAgICog dGVzdGluZy9JbnRlcm5hbHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW50ZXJuYWxzOjpzZXRa b29tQW5pbWF0b3JTY2FsZSk6CisgICAgICAgICogdGVzdGluZy9JbnRlcm5hbHMuaDoKKyAgICAg ICAgKiB0ZXN0aW5nL0ludGVybmFscy5pZGw6CisKIDIwMTEtMDktMDUgIFBhdmVsIFBvZGl2aWxv diAgPHBvZGl2aWxvdkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogcmUt aW1wbGVtZW50IFJhd1NvdXJjZUNvZGUuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdl L1NldHRpbmdzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCmluZGV4IDEw MjhiN2JiZjM0YWM0MjNmMzNlYTEyN2EyNjg3ZDY3ZDI3NjE3YTEuLjdmZTU2M2U3ZjI3NDRhODBh ZDZhZTViMzkxY2JiMjdhNzhjOTY4ZGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv U2V0dGluZ3MuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCkBAIC0y MTYsNiArMjE2LDcgQEAgU2V0dGluZ3M6OlNldHRpbmdzKFBhZ2UqIHBhZ2UpCiAgICAgLCBtX21l ZGlhUGxheWJhY2tBbGxvd3NJbmxpbmUodHJ1ZSkKICAgICAsIG1fcGFzc3dvcmRFY2hvRW5hYmxl ZChmYWxzZSkKICAgICAsIG1fbG9hZHNJbWFnZXNBdXRvbWF0aWNhbGx5VGltZXIodGhpcywgJlNl dHRpbmdzOjpsb2Fkc0ltYWdlc0F1dG9tYXRpY2FsbHlUaW1lckZpcmVkKQorICAgICwgbV96b29t QW5pbWF0b3JTY2FsZSgxLjApCiB7CiAgICAgLy8gQSBGcmFtZSBtYXkgbm90IGhhdmUgYmVlbiBj cmVhdGVkIHlldCwgc28gd2UgaW5pdGlhbGl6ZSB0aGUgQXRvbWljU3RyaW5nIAogICAgIC8vIGhh c2ggYmVmb3JlIHRyeWluZyB0byB1c2UgaXQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w YWdlL1NldHRpbmdzLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKaW5kZXggNTE1 MTlhZDVhYTMwYmFmZDkzYzM4YTVhN2QzNWIxYzk0ZGVjYWYwZC4uYTliNGFjNTAxMTFlYmQ2YzU5 NTkyM2NlYzhjODlhMGE0MTc3ODc0YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9T ZXR0aW5ncy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAtNDM3LDcg KzQzNywxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdm9pZCBzZXRGb3JjZUNv bXBvc2l0aW5nTW9kZShib29sIGZsYWcpIHsgbV9mb3JjZUNvbXBvc2l0aW5nTW9kZSA9IGZsYWc7 IH0KICAgICAgICAgYm9vbCBmb3JjZUNvbXBvc2l0aW5nTW9kZSgpIHsgcmV0dXJuIG1fZm9yY2VD b21wb3NpdGluZ01vZGU7IH0KLSAgICAgICAgCisKKyAgICAgICAgdm9pZCBzZXRab29tQW5pbWF0 b3JTY2FsZShkb3VibGUgc2NhbGUpIHsgbV96b29tQW5pbWF0b3JTY2FsZSA9IHNjYWxlOyB9Cisg ICAgICAgIGRvdWJsZSB6b29tQW5pbWF0b3JTY2FsZSgpIHsgcmV0dXJuIG1fem9vbUFuaW1hdG9y U2NhbGU7IH0KKwogICAgICAgICB2b2lkIHNldFNob3VsZEluamVjdFVzZXJTY3JpcHRzSW5Jbml0 aWFsRW1wdHlEb2N1bWVudChib29sIGZsYWcpIHsgbV9zaG91bGRJbmplY3RVc2VyU2NyaXB0c0lu SW5pdGlhbEVtcHR5RG9jdW1lbnQgPSBmbGFnOyB9CiAgICAgICAgIGJvb2wgc2hvdWxkSW5qZWN0 VXNlclNjcmlwdHNJbkluaXRpYWxFbXB0eURvY3VtZW50KCkgeyByZXR1cm4gbV9zaG91bGRJbmpl Y3RVc2VyU2NyaXB0c0luSW5pdGlhbEVtcHR5RG9jdW1lbnQ7IH0KIApAQCAtNTk2LDYgKzU5OSw4 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgc3RhdGljIGJvb2wgZ0FWRm91bmRhdGlv bkVuYWJsZWQ7CiAjZW5kaWYKIAorICAgICAgICBkb3VibGUgbV96b29tQW5pbWF0b3JTY2FsZTsK KwogI2lmIFVTRShTQUZBUklfVEhFTUUpCiAgICAgICAgIHN0YXRpYyBib29sIGdTaG91bGRQYWlu dE5hdGl2ZUNvbnRyb2xzOwogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVt LmNwcAppbmRleCA0NTE5ZGVkMjM5YzZmZDZmMTMxN2ZiYmVjNmI1Mzg5MzlhM2YxZjk1Li4yZTJi YTJkODFjMTFjYWYxMzQyODI5OWQxYzQ5NTE1YzU3NjZlOWI1IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0u Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVy UmVuZGVyZXJDaHJvbWl1bS5jcHAKQEAgLTE2Myw2ICsxNjMsNyBAQCBMYXllclJlbmRlcmVyQ2hy b21pdW06OkxheWVyUmVuZGVyZXJDaHJvbWl1bShDQ0xheWVyVHJlZUhvc3QqIG93bmVyLAogICAg ICwgbV9vd25lckltcGwob3duZXJJbXBsKQogICAgICwgbV9jdXJyZW50UmVuZGVyU3VyZmFjZSgw KQogICAgICwgbV9vZmZzY3JlZW5GcmFtZWJ1ZmZlcklkKDApCisgICAgLCBtX3RleHR1cmVab29t KDEuMCkKICAgICAsIG1fY29udGV4dChjb250ZXh0KQogICAgICwgbV9kZWZhdWx0UmVuZGVyU3Vy ZmFjZSgwKQogewpAQCAtMjkzLDEzICsyOTQsMTUgQEAgdm9pZCBMYXllclJlbmRlcmVyQ2hyb21p dW06OmRyYXdMYXllcnNJbnRlcm5hbCgpCiAgICAgQ0NMYXllckxpc3QgcmVuZGVyU3VyZmFjZUxh eWVyTGlzdDsKICAgICByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0LmFwcGVuZChyb290RHJhd0xheWVy KTsKIAotICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4IGlkZW50aXR5TWF0cml4OworICAgIFRyYW5z Zm9ybWF0aW9uTWF0cml4IHpvb21NYXRyaXg7CisgICAgaWYgKG1fdGV4dHVyZVpvb20gIT0gMS4w KQorICAgICAgICB6b29tTWF0cml4LnNjYWxlM2QobV90ZXh0dXJlWm9vbSwgbV90ZXh0dXJlWm9v bSwgMS4wKTsKICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlID0gcm9vdERyYXdMYXllci0+cmVu ZGVyU3VyZmFjZSgpOwogICAgIG1fZGVmYXVsdFJlbmRlclN1cmZhY2UtPmNsZWFyTGF5ZXJMaXN0 KCk7CiAKICAgICB7CiAgICAgICAgIFRSQUNFX0VWRU5UKCJMYXllclJlbmRlcmVyQ2hyb21pdW06 OmRyYXdMYXllcnNJbnRlcm5hbDo6Y2FsY0RyYXdFdGMiLCB0aGlzLCAwKTsKLSAgICAgICAgQ0NM YXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVEcmF3VHJhbnNmb3Jtc0FuZFZpc2liaWxpdHko cm9vdERyYXdMYXllciwgcm9vdERyYXdMYXllciwgaWRlbnRpdHlNYXRyaXgsIGlkZW50aXR5TWF0 cml4LCByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0LCBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5sYXll ckxpc3QoKSwgJm1fbGF5ZXJTb3J0ZXIsIG1fY2FwYWJpbGl0aWVzLm1heFRleHR1cmVTaXplKTsK KyAgICAgICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVEcmF3VHJhbnNmb3Jtc0Fu ZFZpc2liaWxpdHkocm9vdERyYXdMYXllciwgcm9vdERyYXdMYXllciwgem9vbU1hdHJpeCwgem9v bU1hdHJpeCwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCwgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZS0+ bGF5ZXJMaXN0KCksICZtX2xheWVyU29ydGVyLCBtX2NhcGFiaWxpdGllcy5tYXhUZXh0dXJlU2l6 ZSk7CiAgICAgfQogCiAgICAgLy8gVGhlIEdMIHZpZXdwb3J0IGNvdmVycyB0aGUgZW50aXJlIHZp c2libGUgYXJlYSwgaW5jbHVkaW5nIHRoZSBzY3JvbGxiYXJzLgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVt LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uaAppbmRleCBmMDUyZWQ2OWI5OGY4MGM1M2U2N2I1NGZiM2Q3YWY1YTY4NzIx NGZiLi4yNjU1MDFhNmJkMjY5YmI2NTNjMDQ3ZWZlZDAyMGI0MGUyNTMzNjAyIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVy Q2hyb21pdW0uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaApAQCAtMTA5LDYgKzEwOSw5IEBAIHB1YmxpYzoKICAg ICAvLyBwdXRzIGJhY2tidWZmZXIgb25zY3JlZW4KICAgICB2b2lkIHByZXNlbnQoKTsKIAorICAg IHZvaWQgc2V0VGV4dHVyZVpvb20oZG91YmxlIGZhY3RvcikgeyBtX3RleHR1cmVab29tID0gZmFj dG9yOyB9CisgICAgZG91YmxlIGdldFRleHR1cmVab29tKCkgeyByZXR1cm4gbV90ZXh0dXJlWm9v bTsgfQorCiAgICAgdW5zaWduZWQgY3JlYXRlTGF5ZXJUZXh0dXJlKCk7CiAgICAgdm9pZCBkZWxl dGVMYXllclRleHR1cmUodW5zaWduZWQpOwogCkBAIC0xOTIsNiArMTk1LDcgQEAgcHJpdmF0ZToK IAogICAgIENDUmVuZGVyU3VyZmFjZSogbV9jdXJyZW50UmVuZGVyU3VyZmFjZTsKICAgICB1bnNp Z25lZCBtX29mZnNjcmVlbkZyYW1lYnVmZmVySWQ7CisgICAgZG91YmxlIG1fdGV4dHVyZVpvb207 CiAKICAgICAvLyBTdG9yZSB2YWx1ZXMgdGhhdCBhcmUgc2hhcmVkIGJldHdlZW4gaW5zdGFuY2Vz IG9mIGVhY2ggbGF5ZXIgdHlwZQogICAgIC8vIGFzc29jaWF0ZWQgd2l0aCB0aGlzIGluc3RhbmNl IG9mIHRoZSBjb21wb3NpdG9yLiBTaW5jZSB0aGVyZSBjYW4gYmUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVy VHJlZUhvc3QuY3BwCmluZGV4IGYxMjQ5NWI2NTVmMzljN2Y2OWE0ZjcwYzI0ZDc3ZjgxMzA4MTRj YmIuLjA2NjVlODNjZDM2NDYzYWVlMDA0YTlhY2JlMDdiZmQwMWRkZGUxM2YgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVl SG9zdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Y2MvQ0NMYXllclRyZWVIb3N0LmNwcApAQCAtNTQsNiArNTQsNyBAQCBDQ0xheWVyVHJlZUhvc3Q6 OkNDTGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJlZUhvc3RDbGllbnQqIGNsaWVudCwgY29uc3QgQ0NT ZXR0aW5ncwogICAgICwgbV9mcmFtZU51bWJlcigwKQogICAgICwgbV9ub25Db21wb3NpdGVkQ29u dGVudEhvc3QoTm9uQ29tcG9zaXRlZENvbnRlbnRIb3N0OjpjcmVhdGUobV9jbGllbnQtPmNyZWF0 ZVJvb3RMYXllclBhaW50ZXIoKSkpCiAgICAgLCBtX3NldHRpbmdzKHNldHRpbmdzKQorICAgICwg bV90ZXh0dXJlWm9vbSgxLjApCiAgICAgLCBtX3Zpc2libGUodHJ1ZSkKIHsKIH0KQEAgLTExNSw2 ICsxMTYsNyBAQCB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6Y29tbWl0VG8oQ0NMYXllclRyZWVIb3N0 SW1wbCogaG9zdEltcGwpCiAgICAgbV91cGRhdGVMaXN0LmNsZWFyKCk7CiAKICAgICBob3N0SW1w bC0+c2V0VmlzaWJsZShtX3Zpc2libGUpOworICAgIGhvc3RJbXBsLT5zZXRUZXh0dXJlWm9vbSh0 ZXh0dXJlWm9vbSgpKTsKICAgICBob3N0SW1wbC0+c2V0Vmlld3BvcnQodmlld3BvcnRTaXplKCkp OwogCiAgICAgLy8gU3luY2hyb25pemUgdHJlZXMsIGlmIG9uZSBleGlzdHMgYXQgYWxsLi4uCkBA IC0xODIsNiArMTg0LDE2IEBAIGNvbnN0IExheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMmIENDTGF5 ZXJUcmVlSG9zdDo6bGF5ZXJSZW5kZXJlckNhcGFiaWxpdGllcygpIGNvCiAgICAgcmV0dXJuIG1f cHJveHktPmxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMoKTsKIH0KIAordm9pZCBDQ0xheWVyVHJl ZUhvc3Q6OnNldFRleHR1cmVab29tKGNvbnN0IGRvdWJsZSB6b29tKQoreworICAgIGJvb2wgem9v bUNoYW5nZWQgPSBtX3RleHR1cmVab29tICE9IHpvb207CisKKyAgICBtX3RleHR1cmVab29tID0g em9vbTsKKworICAgIGlmICh6b29tQ2hhbmdlZCkKKyAgICAgICAgc2V0TmVlZHNDb21taXRBbmRS ZWRyYXcoKTsKK30KKwogdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnNldE5lZWRzQ29tbWl0QW5kUmVk cmF3KCkKIHsKICNpZiBVU0UoVEhSRUFERURfQ09NUE9TSVRJTkcpCkBAIC0yNzgsMTEgKzI5MCwx MSBAQCB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6dXBkYXRlTGF5ZXJzKExheWVyQ2hyb21pdW0qIHJv b3RMYXllcikKICAgICBSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIHJvb3RSZW5kZXJTdXJmYWNlID0g cm9vdExheWVyLT5yZW5kZXJTdXJmYWNlKCk7CiAgICAgcm9vdFJlbmRlclN1cmZhY2UtPmNsZWFy TGF5ZXJMaXN0KCk7CiAKLSAgICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCBpZGVudGl0eU1hdHJpeDsK LQorICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4IHpvb21NYXRyaXg7CisgICAgem9vbU1hdHJpeC5z Y2FsZTNkKG1fdGV4dHVyZVpvb20sIG1fdGV4dHVyZVpvb20sIDEuMCk7CiAgICAgewogICAgICAg ICBUUkFDRV9FVkVOVCgiQ0NMYXllclRyZWVIb3N0Ojp1cGRhdGVMYXllcnM6OmNhbGNEcmF3RXRj IiwgdGhpcywgMCk7Ci0gICAgICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJh d1RyYW5zZm9ybXNBbmRWaXNpYmlsaXR5KHJvb3RMYXllciwgcm9vdExheWVyLCBpZGVudGl0eU1h dHJpeCwgaWRlbnRpdHlNYXRyaXgsIG1fdXBkYXRlTGlzdCwgcm9vdFJlbmRlclN1cmZhY2UtPmxh eWVyTGlzdCgpLCBsYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzKCkubWF4VGV4dHVyZVNpemUpOwor ICAgICAgICBDQ0xheWVyVHJlZUhvc3RDb21tb246OmNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zQW5k VmlzaWJpbGl0eShyb290TGF5ZXIsIHJvb3RMYXllciwgem9vbU1hdHJpeCwgem9vbU1hdHJpeCwg bV91cGRhdGVMaXN0LCByb290UmVuZGVyU3VyZmFjZS0+bGF5ZXJMaXN0KCksIGxheWVyUmVuZGVy ZXJDYXBhYmlsaXRpZXMoKS5tYXhUZXh0dXJlU2l6ZSk7CiAgICAgfQogCiAgICAgcGFpbnRMYXll ckNvbnRlbnRzKG1fdXBkYXRlTGlzdCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuaCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oCmluZGV4 IDQ4ODk0ODQ0MWQ4NWMwOWQwYjQxNzc1ZmEyYWM2NWNlMzNjY2VhMDcuLmY4NTMyMzljODQxZDU1 ZDAyZGViNGFlMTZjZTBkYjUyY2E3ZWE3YTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5o CkBAIC0xMzAsNiArMTMwLDcgQEAgcHVibGljOgogICAgIGludCBmcmFtZU51bWJlcigpIGNvbnN0 IHsgcmV0dXJuIG1fZnJhbWVOdW1iZXI7IH0KIAogICAgIHZvaWQgaW52YWxpZGF0ZVJvb3RMYXll clJlY3QoY29uc3QgSW50UmVjdCYgZGlydHlSZWN0KTsKKyAgICB2b2lkIHNldFRleHR1cmVab29t KGNvbnN0IGRvdWJsZSk7CiAKICAgICBjb25zdCBMYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzJiBs YXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzKCkgY29uc3Q7CiAKQEAgLTE0OCw2ICsxNDksNyBAQCBw dWJsaWM6CiAgICAgdm9pZCBzZXRWaWV3cG9ydChjb25zdCBJbnRTaXplJiB2aWV3cG9ydFNpemUs IGNvbnN0IEludFNpemUmIGNvbnRlbnRzU2l6ZSwgY29uc3QgSW50UG9pbnQmIHNjcm9sbFBvc2l0 aW9uKTsKIAogICAgIGNvbnN0IEludFNpemUmIHZpZXdwb3J0U2l6ZSgpIGNvbnN0IHsgcmV0dXJu IG1fdmlld3BvcnRTaXplOyB9CisgICAgZG91YmxlIHRleHR1cmVab29tKCkgY29uc3QgeyByZXR1 cm4gbV90ZXh0dXJlWm9vbTsgfQogICAgIFRleHR1cmVNYW5hZ2VyKiBjb250ZW50c1RleHR1cmVN YW5hZ2VyKCkgY29uc3Q7CiAKICAgICB2b2lkIHNldFZpc2libGUoYm9vbCk7CkBAIC0xODcsNiAr MTg5LDcgQEAgcHJpdmF0ZToKICAgICBDQ1NldHRpbmdzIG1fc2V0dGluZ3M7CiAKICAgICBJbnRT aXplIG1fdmlld3BvcnRTaXplOworICAgIGRvdWJsZSBtX3RleHR1cmVab29tOwogICAgIGJvb2wg bV92aXNpYmxlOwogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0SW1wbC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3RJbXBsLmNwcApp bmRleCA5ZGUyMDI5ZGVjN2QyMzNlY2VlYWFjYTU2NjY3MzkxOTMzNGVkM2RhLi5iODQ3NWRjNDlj MzM5NzI5NDNhZTQ0ZDlhZjQ0NzQ3YWZkMDYyY2I2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3RJbXBsLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVy VHJlZUhvc3RJbXBsLmNwcApAQCAtNDcsNiArNDcsNyBAQCBDQ0xheWVyVHJlZUhvc3RJbXBsOjpD Q0xheWVyVHJlZUhvc3RJbXBsKGNvbnN0IENDU2V0dGluZ3MmIHNldHRpbmdzKQogICAgIDogbV9z b3VyY2VGcmFtZU51bWJlcigtMSkKICAgICAsIG1fZnJhbWVOdW1iZXIoMCkKICAgICAsIG1fc2V0 dGluZ3Moc2V0dGluZ3MpCisgICAgLCBtX3RleHR1cmVab29tKDEuMCkKIHsKIH0KIApAQCAtMTU1 LDQgKzE1NiwxMCBAQCB2b2lkIENDTGF5ZXJUcmVlSG9zdEltcGw6OnNldFZpZXdwb3J0KGNvbnN0 IEludFNpemUmIHZpZXdwb3J0U2l6ZSkKICAgICAgICAgbV9sYXllclJlbmRlcmVyLT52aWV3cG9y dENoYW5nZWQoKTsKIH0KIAordm9pZCBDQ0xheWVyVHJlZUhvc3RJbXBsOjpzZXRUZXh0dXJlWm9v bShkb3VibGUgem9vbSkKK3sKKyAgICBtX3RleHR1cmVab29tID0gem9vbTsKKyAgICBtX2xheWVy UmVuZGVyZXItPnNldFRleHR1cmVab29tKHpvb20pOworfQorCiB9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3RJ bXBsLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xh eWVyVHJlZUhvc3RJbXBsLmgKaW5kZXggNTNhNGQ1NTI0YTU3YjgzNWRlNGQ4MzIwZWFjMGM2NDll NjYwNjJiZi4uMzc5NmVmMGVjZjg1ZGQ0MTI0MjZkNDNkMGVhYWRkOGQ4ZTIzYzUzYiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXll clRyZWVIb3N0SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdEltcGwuaApAQCAtNzUsNiArNzUsOCBAQCBwdWJsaWM6 CiAKICAgICB2b2lkIHNldFZpZXdwb3J0KGNvbnN0IEludFNpemUmIHZpZXdwb3J0U2l6ZSk7CiAg ICAgY29uc3QgSW50U2l6ZSYgdmlld3BvcnRTaXplKCkgY29uc3QgeyByZXR1cm4gbV92aWV3cG9y dFNpemU7IH0KKyAgICB2b2lkIHNldFRleHR1cmVab29tKGRvdWJsZSk7CisgICAgZG91YmxlIHRl eHR1cmVab29tKCkgY29uc3QgeyByZXR1cm4gbV90ZXh0dXJlWm9vbTsgfQogCiBwcm90ZWN0ZWQ6 CiAgICAgZXhwbGljaXQgQ0NMYXllclRyZWVIb3N0SW1wbChjb25zdCBDQ1NldHRpbmdzJik7CkBA IC04Niw2ICs4OCw3IEBAIHByaXZhdGU6CiAgICAgUmVmUHRyPENDTGF5ZXJJbXBsPiBtX3Jvb3RM YXllckltcGw7CiAgICAgQ0NTZXR0aW5ncyBtX3NldHRpbmdzOwogICAgIEludFNpemUgbV92aWV3 cG9ydFNpemU7CisgICAgZG91YmxlIG1fdGV4dHVyZVpvb207CiB9OwogCiB9OwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRlcm5hbHMuY3BwIGIvU291cmNlL1dlYkNvcmUv dGVzdGluZy9JbnRlcm5hbHMuY3BwCmluZGV4IGU0NGI1Zjc1ZTYxMjk5Yjk1ODliMzFhZTZmMDRm NDFmYjRhZTFjNjAuLjBkYzI3MjNlZmYzYzhiMDYwNDg0Yjc5YTIzZDcxYTY1OTQxNjUwMTYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5jcHAKQEAgLTI0Miw2ICsyNDIsMTYgQEAgdm9p ZCBJbnRlcm5hbHM6OnNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKERvY3VtZW50KiBkb2N1bWVudCwg Ym9vbCBlbmFibGVkLCBFeGNlcHQKICAgICBkb2N1bWVudC0+c2V0dGluZ3MoKS0+c2V0Rm9yY2VD b21wb3NpdGluZ01vZGUoZW5hYmxlZCk7CiB9CiAKK3ZvaWQgSW50ZXJuYWxzOjpzZXRab29tQW5p bWF0b3JTY2FsZShEb2N1bWVudCAqZG9jdW1lbnQsIGRvdWJsZSBzY2FsZSwgRXhjZXB0aW9uQ29k ZSYgZWMpCit7CisgICAgaWYgKCFkb2N1bWVudCB8fCAhZG9jdW1lbnQtPnNldHRpbmdzKCkpIHsK KyAgICAgICAgZWMgPSBJTlZBTElEX0FDQ0VTU19FUlI7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKKyAgICBkb2N1bWVudC0+c2V0dGluZ3MoKS0+c2V0Wm9vbUFuaW1hdG9yU2NhbGUoc2NhbGUp OworfQorCiB2b2lkIEludGVybmFsczo6c2V0UGFzc3dvcmRFY2hvRW5hYmxlZChEb2N1bWVudCog ZG9jdW1lbnQsIGJvb2wgZW5hYmxlZCwgRXhjZXB0aW9uQ29kZSYgZWMpCiB7CiAgICAgaWYgKCFk b2N1bWVudCB8fCAhZG9jdW1lbnQtPnNldHRpbmdzKCkpIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmggYi9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVy bmFscy5oCmluZGV4IDU5MjQ5ZTNmMWZhZjdmYzg1NWExZGU5NmFjM2Q1ZmZkZDg4OWNlM2UuLjBh NTRlNjk4NmFiZjA4OTI3MTg4ODMxN2I4M2Y5MGE5NDBiMjExM2IgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmgKKysrIGIvU291cmNlL1dlYkNvcmUvdGVzdGlu Zy9JbnRlcm5hbHMuaApAQCAtNzcsNiArNzcsNyBAQCBwdWJsaWM6CiAgICAgUGFzc1JlZlB0cjxS YW5nZT4gbWFya2VyUmFuZ2VGb3JOb2RlKE5vZGUqLCB1bnNpZ25lZCwgRXhjZXB0aW9uQ29kZSYp OwogCiAgICAgdm9pZCBzZXRGb3JjZUNvbXBvc2l0aW5nTW9kZShEb2N1bWVudCosIGJvb2wgZW5h YmxlZCwgRXhjZXB0aW9uQ29kZSYpOworICAgIHZvaWQgc2V0Wm9vbUFuaW1hdG9yU2NhbGUoRG9j dW1lbnQqLCBkb3VibGUgc2NhbGUsIEV4Y2VwdGlvbkNvZGUmKTsKIAogICAgIHZvaWQgc2V0UGFz c3dvcmRFY2hvRW5hYmxlZChEb2N1bWVudCosIGJvb2wgZW5hYmxlZCwgRXhjZXB0aW9uQ29kZSYp OwogICAgIHZvaWQgc2V0UGFzc3dvcmRFY2hvRHVyYXRpb25JblNlY29uZHMoRG9jdW1lbnQqLCBk b3VibGUgZHVyYXRpb25JblNlY29uZHMsIEV4Y2VwdGlvbkNvZGUmKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmlkbCBiL1NvdXJjZS9XZWJDb3JlL3Rlc3Rp bmcvSW50ZXJuYWxzLmlkbAppbmRleCAyZGUzZmM0YjFlOGY0MGViOWRkZGQ2YTlkYWQ5N2M2MTIw NGUyYzY0Li5iYTZiN2Y0NTM1ZDljZjZmMjA2ZTcxZjAwZGE3YzMxZmVjZjZjNWQ0IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5pZGwKKysrIGIvU291cmNlL1dl YkNvcmUvdGVzdGluZy9JbnRlcm5hbHMuaWRsCkBAIC01MSw2ICs1MSw3IEBAIG1vZHVsZSB3aW5k b3cgewogICAgICAgICBSYW5nZSBtYXJrZXJSYW5nZUZvck5vZGUoaW4gTm9kZSBub2RlLCBpbiB1 bnNpZ25lZCBsb25nIGluZGV4KSByYWlzZXMoRE9NRXhjZXB0aW9uKTsKIAogICAgICAgICB2b2lk IHNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKGluIERvY3VtZW50IGRvY3VtZW50LCBpbiBib29sZWFu IGVuYWJsZWQpIHJhaXNlcyhET01FeGNlcHRpb24pOworICAgICAgICB2b2lkIHNldFpvb21Bbmlt YXRvclNjYWxlKGluIERvY3VtZW50IGRvY3VtZW50LCBpbiBkb3VibGUgc2NhbGUpIHJhaXNlcyhE T01FeGNlcHRpb24pOwogCiAgICAgICAgIHZvaWQgc2V0UGFzc3dvcmRFY2hvRW5hYmxlZChpbiBE b2N1bWVudCBkb2N1bWVudCwgaW4gYm9vbGVhbiBlbmFibGVkKSByYWlzZXMoRE9NRXhjZXB0aW9u KTsKICAgICAgICAgdm9pZCBzZXRQYXNzd29yZEVjaG9EdXJhdGlvbkluU2Vjb25kcyhpbiBEb2N1 bWVudCBkb2N1bWVudCwgaW4gZG91YmxlIGR1cmF0aW9uSW5TZWNvbmRzKSByYWlzZXMoRE9NRXhj ZXB0aW9uKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggNzNkM2VjM2RiYzA3ZWE1NTIy MDVhZjM0MDE2MWI1ZWE5NGE4NTVlNi4uMThlOGNkMWFmZTIxMjY2OWJkNTI0M2Y4YWJkYzgzNThk MjlhZDAzYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAorMjAx MS0wOS0wNiAgVy4gSmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgW2Nocm9taXVtXSBBZGQgYmFja2VuZCBjb21wb3NpdG9yIHN1cHBvcnQgZm9yIHJlc2Nh bGluZyAoem9vbWluZykgdGV4dHVyZXMgZHVyaW5nIHpvb20gYW5pbWF0aW9uLgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjY0NzIKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHB1YmxpYy9XZWJTZXR0aW5n cy5oOgorICAgICAgICAqIHNyYy9XZWJTZXR0aW5nc0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0 OjpXZWJTZXR0aW5nc0ltcGw6OldlYlNldHRpbmdzSW1wbCk6CisgICAgICAgIChXZWJLaXQ6Oldl YlNldHRpbmdzSW1wbDo6c2V0Wm9vbUFuaW1hdG9yU2NhbGUpOgorICAgICAgICAqIHNyYy9XZWJT ZXR0aW5nc0ltcGwuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViU2V0dGluZ3NJbXBsOjpnZXRab29t QW5pbWF0b3JTY2FsZSk6CisgICAgICAgICogc3JjL1dlYlZpZXdJbXBsLmNwcDoKKyAgICAgICAg KFdlYktpdDo6V2ViVmlld0ltcGw6OnNldFpvb21MZXZlbCk6CisgICAgICAgIChXZWJLaXQ6Oldl YlZpZXdJbXBsOjpzZXRSb290TGF5ZXJOZWVkc0Rpc3BsYXkpOgorCiAyMDExLTA5LTA0ICBBZGFt IEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAgW0Nocm9taXVtXSBBZGQgbXV0 bGlwbGUgdG8gV2ViUG9wdXBNZW51SW5mbyBmb3IgQW5kcm9pZApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViU2V0dGluZ3MuaCBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vcHVibGljL1dlYlNldHRpbmdzLmgKaW5kZXggMDQ0ZDA2MTg3NzRmZWY0MTg1M2M2YjAx YzIyOGU3NjgwM2VjYzM4NS4uODZhYWVmMzkwODU3NDg4NGE3YWIxZTUyNTM5NmRiZjM0YmNjNWVh OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViU2V0dGluZ3Mu aAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJTZXR0aW5ncy5oCkBAIC0x MDQsNiArMTA0LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzZXRFZGl0aW5nQmVoYXZp b3IoRWRpdGluZ0JlaGF2aW9yKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHNldEFjY2VsZXJhdGVk Q29tcG9zaXRpbmdFbmFibGVkKGJvb2wpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgc2V0Rm9yY2VD b21wb3NpdGluZ01vZGUoYm9vbCkgPSAwOworICAgIHZpcnR1YWwgdm9pZCBzZXRab29tQW5pbWF0 b3JTY2FsZShkb3VibGUpID0gMDsKKyAgICB2aXJ0dWFsIGRvdWJsZSBnZXRab29tQW5pbWF0b3JT Y2FsZSgpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgc2V0Q29tcG9zaXRlVG9UZXh0dXJlRW5hYmxl ZChib29sKSA9IDA7CiAgICAgdmlydHVhbCBib29sIGNvbXBvc2l0ZVRvVGV4dHVyZUVuYWJsZWQo KSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHNldEFjY2VsZXJhdGVkQ29tcG9zaXRpbmdG b3IzRFRyYW5zZm9ybXNFbmFibGVkKGJvb2wpID0gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwCmluZGV4IGI0NjM0MDE5MWUyZmI2MTJkNmNmMzNj YWQ2Nzk2NmQzYjBkMjM0ZWMuLmFiYzUyMThjMGExZDJmN2NjZjUyMzAxYjI1ODNlZWI2YzY3ZGE1 YmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1w bC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNw cApAQCAtNTAsNiArNTAsNyBAQCBXZWJTZXR0aW5nc0ltcGw6OldlYlNldHRpbmdzSW1wbChTZXR0 aW5ncyogc2V0dGluZ3MpCiAgICAgLCBtX2NvbXBvc2l0ZVRvVGV4dHVyZUVuYWJsZWQoZmFsc2Up CiAgICAgLCBtX3Nob3dGUFNDb3VudGVyKGZhbHNlKQogICAgICwgbV9zaG93UGxhdGZvcm1MYXll clRyZWUoZmFsc2UpCisgICAgLCBtX3pvb21BbmltYXRvclNjYWxlKDEuMCkKIHsKICAgICBBU1NF UlQoc2V0dGluZ3MpOwogfQpAQCAtMzE4LDYgKzMxOSwxMiBAQCB2b2lkIFdlYlNldHRpbmdzSW1w bDo6c2V0Rm9yY2VDb21wb3NpdGluZ01vZGUoYm9vbCBlbmFibGVkKQogICAgIG1fc2V0dGluZ3Mt PnNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKGVuYWJsZWQpOwogfQogCit2b2lkIFdlYlNldHRpbmdz SW1wbDo6c2V0Wm9vbUFuaW1hdG9yU2NhbGUoZG91YmxlIHNjYWxlKQoreworICAgIGlmIChzY2Fs ZSA+IDAuMCkKKyAgICAgICAgbV96b29tQW5pbWF0b3JTY2FsZSA9IHNjYWxlOworfQorCiB2b2lk IFdlYlNldHRpbmdzSW1wbDo6c2V0Q29tcG9zaXRlVG9UZXh0dXJlRW5hYmxlZChib29sIGVuYWJs ZWQpCiB7CiAgICAgbV9jb21wb3NpdGVUb1RleHR1cmVFbmFibGVkID0gZW5hYmxlZDsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5oIGIvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmgKaW5kZXggMTkwNjk5NWRi Nzk1MTE5OTQxYmExOTFjNmU1NjIwZGIwNTE5YWRkMC4uNzYwNTk0NmFkMDhkZjIzM2Y2NTMxMGYw MGQ4ZWUzMTEwNzI1NGNmZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViU2V0dGluZ3NJbXBsLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0 dGluZ3NJbXBsLmgKQEAgLTk2LDYgKzk2LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBz ZXRFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9yKTsKICAgICB2aXJ0dWFsIHZvaWQgc2V0 QWNjZWxlcmF0ZWRDb21wb3NpdGluZ0VuYWJsZWQoYm9vbCk7CiAgICAgdmlydHVhbCB2b2lkIHNl dEZvcmNlQ29tcG9zaXRpbmdNb2RlKGJvb2wpOworICAgIHZpcnR1YWwgdm9pZCBzZXRab29tQW5p bWF0b3JTY2FsZShkb3VibGUpOworICAgIHZpcnR1YWwgZG91YmxlIGdldFpvb21BbmltYXRvclNj YWxlKCkgeyByZXR1cm4gbV96b29tQW5pbWF0b3JTY2FsZTsgfQogICAgIHZpcnR1YWwgdm9pZCBz ZXRDb21wb3NpdGVUb1RleHR1cmVFbmFibGVkKGJvb2wpOwogICAgIHZpcnR1YWwgYm9vbCBjb21w b3NpdGVUb1RleHR1cmVFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV9jb21wb3NpdGVUb1RleHR1 cmVFbmFibGVkOyB9CiAgICAgdmlydHVhbCB2b2lkIHNldEFjY2VsZXJhdGVkQ29tcG9zaXRpbmdG b3IzRFRyYW5zZm9ybXNFbmFibGVkKGJvb2wpOwpAQCAtMTI2LDYgKzEyOCw4IEBAIHByaXZhdGU6 CiAgICAgYm9vbCBtX2NvbXBvc2l0ZVRvVGV4dHVyZUVuYWJsZWQ7CiAgICAgYm9vbCBtX3Nob3dG UFNDb3VudGVyOwogICAgIGJvb2wgbV9zaG93UGxhdGZvcm1MYXllclRyZWU7CisKKyAgICBkb3Vi bGUgbV96b29tQW5pbWF0b3JTY2FsZTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4IDZjMjkyYzFkNTgw ODU4OWVjZGUwNWFjMmNjYWQ3NGVhNWEyNTUyYjEuLjFkOTBhNWI5NWUwMGVlNjc1YTFkMDQ3ZTVl MTRjYzc3YzNhNTk0MjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YlZpZXdJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1w bC5jcHAKQEAgLTE4MjMsNiArMTgyMyw5IEBAIGRvdWJsZSBXZWJWaWV3SW1wbDo6em9vbUxldmVs KCkKIAogZG91YmxlIFdlYlZpZXdJbXBsOjpzZXRab29tTGV2ZWwoYm9vbCB0ZXh0T25seSwgZG91 YmxlIHpvb21MZXZlbCkKIHsKKyAgICBpZiAobV9sYXllclRyZWVIb3N0KQorICAgICAgICBtX2xh eWVyVHJlZUhvc3QtPnNldFRleHR1cmVab29tKDEuMCk7CisKICAgICBpZiAoem9vbUxldmVsIDwg bV9taW5pbXVtWm9vbUxldmVsKQogICAgICAgICBtX3pvb21MZXZlbCA9IG1fbWluaW11bVpvb21M ZXZlbDsKICAgICBlbHNlIGlmICh6b29tTGV2ZWwgPiBtX21heGltdW1ab29tTGV2ZWwpCkBAIC0y NTYzLDEwICsyNTY2LDkgQEAgdm9pZCBXZWJWaWV3SW1wbDo6c2V0Um9vdEdyYXBoaWNzTGF5ZXIo R3JhcGhpY3NMYXllciogbGF5ZXIpCiAKIHZvaWQgV2ViVmlld0ltcGw6OnNldFJvb3RMYXllck5l ZWRzRGlzcGxheSgpCiB7Ci0jaWYgVVNFKFRIUkVBREVEX0NPTVBPU0lUSU5HKQogICAgIGlmICht X2xheWVyVHJlZUhvc3QpCi0gICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+c2V0TmVlZHNDb21taXRB bmRSZWRyYXcoKTsKLSNlbHNlCisgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+c2V0VGV4dHVyZVpv b20obV9wYWdlLT5zZXR0aW5ncygpLT56b29tQW5pbWF0b3JTY2FsZSgpKTsKKyNpZiAhVVNFKFRI UkVBREVEX0NPTVBPU0lUSU5HKQogICAgIG1fY2xpZW50LT5zY2hlZHVsZUNvbXBvc2l0ZSgpOwog I2VuZGlmCiB9Cg== 106587 2011-09-07 08:37:49 -0700 2011-09-08 07:25:51 -0700 Patch bug-66472-20110907113535.patch text/plain 19302 wjmaclean U3VidmVyc2lvbiBSZXZpc2lvbjogOTQ2NjgKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRm b3JtL2Nocm9taXVtLWdwdS1saW51eC9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29t LWFuaW1hdG9yLXNjYWxlLXRlc3QtZXhwZWN0ZWQucG5nIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0v Y2hyb21pdW0tZ3B1LWxpbnV4L3BsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5p bWF0b3Itc2NhbGUtdGVzdC1leHBlY3RlZC5wbmcKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjhlYjNmZjMwMGI0MTg1 YmVhNDM4ZjkxY2RlZjRiY2U5MmQ1YTgzZQpHSVQgYmluYXJ5IHBhdGNoCmxpdGVyYWwgMjg3MQp6 Y21lQVNATj8ob2xIeWB1VkJxIWlhMHl+eVV7K3ZZVjJhPmkwKlopPWheaGxBJUBXcyRsSGBvazxt fT9vVCF0aHwKekdlYiskPFYwZypeRilnQCg9PGElXkpIVCleT1dReWkmVHIkUk81WFFlPlg4T2FH bXNZYVNXLUxeWStGOy1vcCs4CnpoYUtWe3tFTlA0YTxHQ2llSG9LMj1pSGUpODUreyhacjxBdnww ez18ZnVUYVdrKEVJfUlEJnp9YUZqdVZLLWdHYQp6ZWM8eEJue2dsMyV6VnFyQFMpeWpHXkE7citg dkpld29ST1lBXi1WN0NXYTE5OWZwUCgyU3lwQWZpUmo5TXN2WXYKeEUqSz1hVkQ5VCNaK1JJUSk7 fTY4cWV0cn1FUn1SRTt8RjcmXkAleG14UGRLVTIyV1ElbXZ2NEZPI3BAWitTVUw3CgpsaXRlcmFs IDAKSGNtVj9kMDAwMDEKCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1 bS1ncHUtbGludXgvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1z Y2FsZS10ZXN0Mi1leHBlY3RlZC5wbmcgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1n cHUtbGludXgvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2Fs ZS10ZXN0Mi1leHBlY3RlZC5wbmcKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDE0MjI2M2FkNDdiN2JhMzZkMjc2ZDJh Y2U1NjA2YjljMGVmZjkxMwpHSVQgYmluYXJ5IHBhdGNoCmxpdGVyYWwgMjg2MQp6Y21lQVNATj8o b2xIeWB1VkJxIWlhMHl+eVV7K3ZZVjJhPmkwKlopPWheaGxBJUBXcyRsSGBvazxtfT9vVG19UDYK enF0cH13Z1QmTlNiQSFZcjxDTWd0V0NQMVlnT3RRWDFCKWJNQk9feV91ZWw1aVQ+Q3Y7OTc4SlJ5 dUVSZGxpNSojCnojYz0pM0tmIVk5ZnlXIWR5QjVyTW9qPnlAMUgqLSVkSGY2dktnXmw5ODVHbnVG ZmImSUdEWlVkVXJQOXYhQHVLLQp6PCEkYkRDWSQjJUcrMC1ScmtULTxMdioxNVBDUkc2Rik9KGFt RDZFcG1+bnVLcEBWYWpGJllTP0RQYzRoak9LI1QKZlQhNVNsWnR4I28kLU8/V2l9d187e21iQyM+ Z1RlfkRXTTRmV05FN0cKCmxpdGVyYWwgMApIY21WP2QwMDAwMQoKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUt dGVzdC5odG1sIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9v bS1hbmltYXRvci1zY2FsZS10ZXN0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYmQwMzlhZDExMTIxZThlNzZh MTNiYzMxNTc3Njk2ZGMyNzQzYzRhYwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC5odG1s CkBAIC0wLDAgKzEsMjUgQEAKKzxodG1sPgorICA8aGVhZD4KKyAgICAgPHNjcmlwdD4KKyAgICAg ICAgaWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICAgICAgICAgIHdpbmRvdy5pbnRlcm5hbHMu c2V0Rm9yY2VDb21wb3NpdGluZ01vZGUoZG9jdW1lbnQsIHRydWUpOworICAgICAgICAgICAgd2lu ZG93LmludGVybmFscy5zZXRab29tQW5pbWF0b3JTY2FsZShkb2N1bWVudCwgMC44KTsKKyAgICAg ICAgfQorICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAg ICAgICB3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCh0cnVlKTsKKyAgICAg ICAgfQorCisgICAgICAgIGZ1bmN0aW9uIGRvVGVzdCgpIHsKKyAgICAgICAgICAgIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJhQm94Iikuc3R5bGUuYmFja2dyb3VuZENvbG9yID0gIiMwMDAwRkYi OyAvLyBDaGFuZ2UgdG8gYmx1ZQorICAgICAgICB9CisKKyAgICAgICB3aW5kb3cuYWRkRXZlbnRM aXN0ZW5lcigibG9hZCIsIGRvVGVzdCwgZmFsc2UpOworICAgICA8L3NjcmlwdD4KKyAgPC9oZWFk PgorPGJvZHk+CisgIDwhLS0gSWYgc3VjY2Vzc2Z1bCwgdGhlIGJsdWUgYm94IHNob3VsZCBzaHJp bmsgdG8gYmUgODB4ODAgYXQgKDgwLDgwKSwgYW5kIGEgYmx1ZSBiYXIKKyAgICAgICBzaG91bGQg YXBwZWFyIGF0IHRoZSByaWdodCBhbmQgYm90dG9tIG9mIHRoZSBzY3JlZW4sIGVhY2ggMjAlIG9m IHRoZSB3aWR0aC9oZWlnaHQuCisgICAgLS0+CisgIDxkaXYgaWQ9ImFCb3giIHN0eWxlPSJ3aWR0 aDoxMDBweDsgaGVpZ2h0OjEwMHB4OyBwb3NpdGlvbjphYnNvbHV0ZTsgbGVmdDoxMDBweDsgdG9w OjEwMHB4OyBiYWNrZ3JvdW5kLWNvbG9yOiNGRjAwMDAiPjwvZGl2PgorPC9ib2R5PgorPC9odG1s PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcv em9vbS1hbmltYXRvci1zY2FsZS10ZXN0Mi5odG1sIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hy b21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0Mi5odG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjgwZGI4YTU3ZjViMjA1ODRhNDU3MDJkYmQ4M2NhOGVlNDM2NjQ2ZGIKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFu aW1hdG9yLXNjYWxlLXRlc3QyLmh0bWwKQEAgLTAsMCArMSwyNCBAQAorPGh0bWw+CisgIDxoZWFk PgorICAgIDxzY3JpcHQ+CisgICAgICAgIGlmICh3aW5kb3cuaW50ZXJuYWxzKSB7CisgICAgICAg ICAgICB3aW5kb3cuaW50ZXJuYWxzLnNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKGRvY3VtZW50LCB0 cnVlKTsKKyAgICAgICAgICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0Wm9vbUFuaW1hdG9yU2NhbGUo ZG9jdW1lbnQsIDEuMjUpOworICAgICAgICB9CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVz dENvbnRyb2xsZXIpIHsKKyAgICAgICAgICAgIHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlci5k dW1wQXNUZXh0KHRydWUpOworICAgICAgICB9CisKKyAgICAgICAgZnVuY3Rpb24gZG9UZXN0KCkg eworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImFCb3giKS5zdHlsZS5iYWNr Z3JvdW5kQ29sb3IgPSAiIzAwMDBGRiI7IC8vIENoYW5nZSB0byBibHVlCisgICAgICAgIH0KKwor ICAgICAgICB3aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcigibG9hZCIsIGRvVGVzdCwgZmFsc2UpOwor ICAgIDwvc2NyaXB0PgorICA8L2hlYWQ+Cis8Ym9keT4KKyAgPCEtLSAgICBJZiBzdWNjZXNzZnVs LCB0aGUgYmx1ZSBib3ggc2hvdWxkIGVubGFyZ2UgdG8gYmUgMTI1eDEyNSBhdCAoMTI1LDEyNSku CisgICAgLS0+CisgIDxkaXYgaWQ9ImFCb3giIHN0eWxlPSJ3aWR0aDoxMDBweDsgaGVpZ2h0OjEw MHB4OyBwb3NpdGlvbjphYnNvbHV0ZTsgbGVmdDoxMDBweDsgdG9wOjEwMHB4OyBiYWNrZ3JvdW5k LWNvbG9yOiNGRjAwMDAiPjwvZGl2PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGI2 MGQ0MjY4NTFmZTllOGJkOWI1MjQ2MjQ0MjhkYTk2YmE2NWJmMmEuLjBmYzMxY2JkMmE4MDkzYmQz YzBjZGMyNGUwMGQyOTMxMDA2MTQ5NTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NCBAQAorMjAx MS0wOS0wNyAgVy4gSmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgW2Nocm9taXVtXSBBZGQgYmFja2VuZCBjb21wb3NpdG9yIHN1cHBvcnQgZm9yIHJlc2Nh bGluZyAoem9vbWluZykgdGV4dHVyZXMgZHVyaW5nIHpvb20gYW5pbWF0aW9uLgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjY0NzIKKworICAgICAgICBU aGlzIHBhdGNoIGNvbnRhaW5zIHBsdW1iaW5nIGZyb20gSW50ZXJuYWxzIHRvIFdlYlZpZXdJbXBs IHRoYXQgY2FuIGJlIHJlbW92ZWQKKyAgICAgICAgYXQgYSBsYXRlciB0aW1lIHdoZW4gdGhlIHpv b20gYW5pbWF0b3IgY29kZSBpcyBjb21wbGV0ZS4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0czogcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRp bmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0Lmh0bWwKKyAgICAgICAgICAgICAgIHBsYXRmb3Jt L2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdDIuaHRtbAorCisg ICAgICAgICogcGFnZS9TZXR0aW5ncy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTZXR0aW5nczo6 U2V0dGluZ3MpOgorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuaDoKKyAgICAgICAgKFdlYkNvcmU6 OlNldHRpbmdzOjpzZXRab29tQW5pbWF0b3JTY2FsZSk6CisgICAgICAgIChXZWJDb3JlOjpTZXR0 aW5nczo6em9vbUFuaW1hdG9yU2NhbGUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXll clJlbmRlcmVyQ2hyb21pdW06OkxheWVyUmVuZGVyZXJDaHJvbWl1bSk6CisgICAgICAgIChXZWJD b3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnNJbnRlcm5hbCk6CisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmg6Cisg ICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OnNldFRleHR1cmVab29tKToK KyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6Z2V0VGV4dHVyZVpvb20p OgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9z dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OkNDTGF5ZXJUcmVlSG9z dCk6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OmNvbW1pdFRvKToKKyAgICAg ICAgKFdlYkNvcmU6OkNDTGF5ZXJUcmVlSG9zdDo6c2V0VGV4dHVyZVpvb20pOgorICAgICAgICAo V2ViQ29yZTo6Q0NMYXllclRyZWVIb3N0Ojp1cGRhdGVMYXllcnMpOgorICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oOgorICAgICAgICAoV2Vi Q29yZTo6Q0NMYXllclRyZWVIb3N0Ojp0ZXh0dXJlWm9vbSk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0SW1wbC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3RJbXBsOjpDQ0xheWVyVHJlZUhvc3RJbXBsKToKKyAgICAg ICAgKFdlYkNvcmU6OkNDTGF5ZXJUcmVlSG9zdEltcGw6OnNldFRleHR1cmVab29tKToKKyAgICAg ICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3RJbXBsLmg6 CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3RJbXBsOjp0ZXh0dXJlWm9vbSk6Cisg ICAgICAgICogdGVzdGluZy9JbnRlcm5hbHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW50ZXJu YWxzOjpzZXRab29tQW5pbWF0b3JTY2FsZSk6CisgICAgICAgICogdGVzdGluZy9JbnRlcm5hbHMu aDoKKyAgICAgICAgKiB0ZXN0aW5nL0ludGVybmFscy5pZGw6CisKIDIwMTEtMDktMDIgIEFuZHJl eSBLb3N5YWtvdiAgPGNhc2VxQGNocm9taXVtLm9yZz4KIAogICAgICAgICBXZWIgSW5zcGVjdG9y OiBbRXh0ZW5zaW9ucyBBUEldIGV4cG9zZSBjb25zb2xlIEFQSQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NldHRpbmdz LmNwcAppbmRleCAxMDI4YjdiYmYzNGFjNDIzZjMzZWExMjdhMjY4N2Q2N2QyNzYxN2ExLi43ZmU1 NjNlN2YyNzQ0YTgwYWQ2YWU1YjM5MWNiYjI3YTc4Yzk2OGRjIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NldHRp bmdzLmNwcApAQCAtMjE2LDYgKzIxNiw3IEBAIFNldHRpbmdzOjpTZXR0aW5ncyhQYWdlKiBwYWdl KQogICAgICwgbV9tZWRpYVBsYXliYWNrQWxsb3dzSW5saW5lKHRydWUpCiAgICAgLCBtX3Bhc3N3 b3JkRWNob0VuYWJsZWQoZmFsc2UpCiAgICAgLCBtX2xvYWRzSW1hZ2VzQXV0b21hdGljYWxseVRp bWVyKHRoaXMsICZTZXR0aW5nczo6bG9hZHNJbWFnZXNBdXRvbWF0aWNhbGx5VGltZXJGaXJlZCkK KyAgICAsIG1fem9vbUFuaW1hdG9yU2NhbGUoMS4wKQogewogICAgIC8vIEEgRnJhbWUgbWF5IG5v dCBoYXZlIGJlZW4gY3JlYXRlZCB5ZXQsIHNvIHdlIGluaXRpYWxpemUgdGhlIEF0b21pY1N0cmlu ZyAKICAgICAvLyBoYXNoIGJlZm9yZSB0cnlpbmcgdG8gdXNlIGl0LgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9TZXR0aW5n cy5oCmluZGV4IDUxNTE5YWQ1YWEzMGJhZmQ5M2MzOGE1YTdkMzViMWM5NGRlY2FmMGQuLmE5YjRh YzUwMTExZWJkNmM1OTU5MjNjZWM4Yzg5YTBhNDE3Nzg3NGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NldHRpbmdz LmgKQEAgLTQzNyw3ICs0MzcsMTAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgICAgIHZv aWQgc2V0Rm9yY2VDb21wb3NpdGluZ01vZGUoYm9vbCBmbGFnKSB7IG1fZm9yY2VDb21wb3NpdGlu Z01vZGUgPSBmbGFnOyB9CiAgICAgICAgIGJvb2wgZm9yY2VDb21wb3NpdGluZ01vZGUoKSB7IHJl dHVybiBtX2ZvcmNlQ29tcG9zaXRpbmdNb2RlOyB9Ci0gICAgICAgIAorCisgICAgICAgIHZvaWQg c2V0Wm9vbUFuaW1hdG9yU2NhbGUoZG91YmxlIHNjYWxlKSB7IG1fem9vbUFuaW1hdG9yU2NhbGUg PSBzY2FsZTsgfQorICAgICAgICBkb3VibGUgem9vbUFuaW1hdG9yU2NhbGUoKSB7IHJldHVybiBt X3pvb21BbmltYXRvclNjYWxlOyB9CisKICAgICAgICAgdm9pZCBzZXRTaG91bGRJbmplY3RVc2Vy U2NyaXB0c0luSW5pdGlhbEVtcHR5RG9jdW1lbnQoYm9vbCBmbGFnKSB7IG1fc2hvdWxkSW5qZWN0 VXNlclNjcmlwdHNJbkluaXRpYWxFbXB0eURvY3VtZW50ID0gZmxhZzsgfQogICAgICAgICBib29s IHNob3VsZEluamVjdFVzZXJTY3JpcHRzSW5Jbml0aWFsRW1wdHlEb2N1bWVudCgpIHsgcmV0dXJu IG1fc2hvdWxkSW5qZWN0VXNlclNjcmlwdHNJbkluaXRpYWxFbXB0eURvY3VtZW50OyB9CiAKQEAg LTU5Niw2ICs1OTksOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHN0YXRpYyBib29s IGdBVkZvdW5kYXRpb25FbmFibGVkOwogI2VuZGlmCiAKKyAgICAgICAgZG91YmxlIG1fem9vbUFu aW1hdG9yU2NhbGU7CisKICNpZiBVU0UoU0FGQVJJX1RIRU1FKQogICAgICAgICBzdGF0aWMgYm9v bCBnU2hvdWxkUGFpbnROYXRpdmVDb250cm9sczsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVt LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVu ZGVyZXJDaHJvbWl1bS5jcHAKaW5kZXggNDUxOWRlZDIzOWM2ZmQ2ZjEzMTdmYmJlYzZiNTM4OTM5 YTNmMWY5NS4uMmUyYmEyZDgxYzExY2FmMTM0MjgyOTlkMWM0OTUxNWM1NzY2ZTliNSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5k ZXJlckNocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCkBAIC0xNjMsNiArMTYzLDcgQEAgTGF5 ZXJSZW5kZXJlckNocm9taXVtOjpMYXllclJlbmRlcmVyQ2hyb21pdW0oQ0NMYXllclRyZWVIb3N0 KiBvd25lciwKICAgICAsIG1fb3duZXJJbXBsKG93bmVySW1wbCkKICAgICAsIG1fY3VycmVudFJl bmRlclN1cmZhY2UoMCkKICAgICAsIG1fb2Zmc2NyZWVuRnJhbWVidWZmZXJJZCgwKQorICAgICwg bV90ZXh0dXJlWm9vbSgxLjApCiAgICAgLCBtX2NvbnRleHQoY29udGV4dCkKICAgICAsIG1fZGVm YXVsdFJlbmRlclN1cmZhY2UoMCkKIHsKQEAgLTI5MywxMyArMjk0LDE1IEBAIHZvaWQgTGF5ZXJS ZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzSW50ZXJuYWwoKQogICAgIENDTGF5ZXJMaXN0IHJl bmRlclN1cmZhY2VMYXllckxpc3Q7CiAgICAgcmVuZGVyU3VyZmFjZUxheWVyTGlzdC5hcHBlbmQo cm9vdERyYXdMYXllcik7CiAKLSAgICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCBpZGVudGl0eU1hdHJp eDsKKyAgICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCB6b29tTWF0cml4OworICAgIGlmIChtX3RleHR1 cmVab29tICE9IDEuMCkKKyAgICAgICAgem9vbU1hdHJpeC5zY2FsZTNkKG1fdGV4dHVyZVpvb20s IG1fdGV4dHVyZVpvb20sIDEuMCk7CiAgICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSA9IHJvb3RE cmF3TGF5ZXItPnJlbmRlclN1cmZhY2UoKTsKICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5j bGVhckxheWVyTGlzdCgpOwogCiAgICAgewogICAgICAgICBUUkFDRV9FVkVOVCgiTGF5ZXJSZW5k ZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzSW50ZXJuYWw6OmNhbGNEcmF3RXRjIiwgdGhpcywgMCk7 Ci0gICAgICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9ybXNB bmRWaXNpYmlsaXR5KHJvb3REcmF3TGF5ZXIsIHJvb3REcmF3TGF5ZXIsIGlkZW50aXR5TWF0cml4 LCBpZGVudGl0eU1hdHJpeCwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCwgbV9kZWZhdWx0UmVuZGVy U3VyZmFjZS0+bGF5ZXJMaXN0KCksICZtX2xheWVyU29ydGVyLCBtX2NhcGFiaWxpdGllcy5tYXhU ZXh0dXJlU2l6ZSk7CisgICAgICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJh d1RyYW5zZm9ybXNBbmRWaXNpYmlsaXR5KHJvb3REcmF3TGF5ZXIsIHJvb3REcmF3TGF5ZXIsIHpv b21NYXRyaXgsIHpvb21NYXRyaXgsIHJlbmRlclN1cmZhY2VMYXllckxpc3QsIG1fZGVmYXVsdFJl bmRlclN1cmZhY2UtPmxheWVyTGlzdCgpLCAmbV9sYXllclNvcnRlciwgbV9jYXBhYmlsaXRpZXMu bWF4VGV4dHVyZVNpemUpOwogICAgIH0KIAogICAgIC8vIFRoZSBHTCB2aWV3cG9ydCBjb3ZlcnMg dGhlIGVudGlyZSB2aXNpYmxlIGFyZWEsIGluY2x1ZGluZyB0aGUgc2Nyb2xsYmFycy4KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVu ZGVyZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggZjA1MmVkNjliOThmODBjNTNlNjdiNTRm YjNkN2FmNWE2ODcyMTRmYi4uMjY1NTAxYTZiZDI2OWJiNjUzYzA0N2VmZWQwMjBiNDBlMjUzMzYw MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v TGF5ZXJSZW5kZXJlckNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKQEAgLTEwOSw2ICsxMDksOSBA QCBwdWJsaWM6CiAgICAgLy8gcHV0cyBiYWNrYnVmZmVyIG9uc2NyZWVuCiAgICAgdm9pZCBwcmVz ZW50KCk7CiAKKyAgICB2b2lkIHNldFRleHR1cmVab29tKGRvdWJsZSBmYWN0b3IpIHsgbV90ZXh0 dXJlWm9vbSA9IGZhY3RvcjsgfQorICAgIGRvdWJsZSBnZXRUZXh0dXJlWm9vbSgpIHsgcmV0dXJu IG1fdGV4dHVyZVpvb207IH0KKwogICAgIHVuc2lnbmVkIGNyZWF0ZUxheWVyVGV4dHVyZSgpOwog ICAgIHZvaWQgZGVsZXRlTGF5ZXJUZXh0dXJlKHVuc2lnbmVkKTsKIApAQCAtMTkyLDYgKzE5NSw3 IEBAIHByaXZhdGU6CiAKICAgICBDQ1JlbmRlclN1cmZhY2UqIG1fY3VycmVudFJlbmRlclN1cmZh Y2U7CiAgICAgdW5zaWduZWQgbV9vZmZzY3JlZW5GcmFtZWJ1ZmZlcklkOworICAgIGRvdWJsZSBt X3RleHR1cmVab29tOwogCiAgICAgLy8gU3RvcmUgdmFsdWVzIHRoYXQgYXJlIHNoYXJlZCBiZXR3 ZWVuIGluc3RhbmNlcyBvZiBlYWNoIGxheWVyIHR5cGUKICAgICAvLyBhc3NvY2lhdGVkIHdpdGgg dGhpcyBpbnN0YW5jZSBvZiB0aGUgY29tcG9zaXRvci4gU2luY2UgdGhlcmUgY2FuIGJlCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xh eWVyVHJlZUhvc3QuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcAppbmRleCBmMTI0OTViNjU1ZjM5YzdmNjlhNGY3MGMy NGQ3N2Y4MTMwODE0Y2JiLi4wNjY1ZTgzY2QzNjQ2M2FlZTAwNGE5YWNiZTA3YmZkMDFkZGRlMTNm IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ0xheWVyVHJlZUhvc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKQEAgLTU0LDYgKzU0LDcgQEAgQ0NM YXllclRyZWVIb3N0OjpDQ0xheWVyVHJlZUhvc3QoQ0NMYXllclRyZWVIb3N0Q2xpZW50KiBjbGll bnQsIGNvbnN0IENDU2V0dGluZ3MKICAgICAsIG1fZnJhbWVOdW1iZXIoMCkKICAgICAsIG1fbm9u Q29tcG9zaXRlZENvbnRlbnRIb3N0KE5vbkNvbXBvc2l0ZWRDb250ZW50SG9zdDo6Y3JlYXRlKG1f Y2xpZW50LT5jcmVhdGVSb290TGF5ZXJQYWludGVyKCkpKQogICAgICwgbV9zZXR0aW5ncyhzZXR0 aW5ncykKKyAgICAsIG1fdGV4dHVyZVpvb20oMS4wKQogICAgICwgbV92aXNpYmxlKHRydWUpCiB7 CiB9CkBAIC0xMTUsNiArMTE2LDcgQEAgdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmNvbW1pdFRvKEND TGF5ZXJUcmVlSG9zdEltcGwqIGhvc3RJbXBsKQogICAgIG1fdXBkYXRlTGlzdC5jbGVhcigpOwog CiAgICAgaG9zdEltcGwtPnNldFZpc2libGUobV92aXNpYmxlKTsKKyAgICBob3N0SW1wbC0+c2V0 VGV4dHVyZVpvb20odGV4dHVyZVpvb20oKSk7CiAgICAgaG9zdEltcGwtPnNldFZpZXdwb3J0KHZp ZXdwb3J0U2l6ZSgpKTsKIAogICAgIC8vIFN5bmNocm9uaXplIHRyZWVzLCBpZiBvbmUgZXhpc3Rz IGF0IGFsbC4uLgpAQCAtMTgyLDYgKzE4NCwxNiBAQCBjb25zdCBMYXllclJlbmRlcmVyQ2FwYWJp bGl0aWVzJiBDQ0xheWVyVHJlZUhvc3Q6OmxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMoKSBjbwog ICAgIHJldHVybiBtX3Byb3h5LT5sYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzKCk7CiB9CiAKK3Zv aWQgQ0NMYXllclRyZWVIb3N0OjpzZXRUZXh0dXJlWm9vbShjb25zdCBkb3VibGUgem9vbSkKK3sK KyAgICBib29sIHpvb21DaGFuZ2VkID0gbV90ZXh0dXJlWm9vbSAhPSB6b29tOworCisgICAgbV90 ZXh0dXJlWm9vbSA9IHpvb207CisKKyAgICBpZiAoem9vbUNoYW5nZWQpCisgICAgICAgIHNldE5l ZWRzQ29tbWl0QW5kUmVkcmF3KCk7Cit9CisKIHZvaWQgQ0NMYXllclRyZWVIb3N0OjpzZXROZWVk c0NvbW1pdEFuZFJlZHJhdygpCiB7CiAjaWYgVVNFKFRIUkVBREVEX0NPTVBPU0lUSU5HKQpAQCAt Mjc4LDExICsyOTAsMTEgQEAgdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnVwZGF0ZUxheWVycyhMYXll ckNocm9taXVtKiByb290TGF5ZXIpCiAgICAgUmVuZGVyU3VyZmFjZUNocm9taXVtKiByb290UmVu ZGVyU3VyZmFjZSA9IHJvb3RMYXllci0+cmVuZGVyU3VyZmFjZSgpOwogICAgIHJvb3RSZW5kZXJT dXJmYWNlLT5jbGVhckxheWVyTGlzdCgpOwogCi0gICAgVHJhbnNmb3JtYXRpb25NYXRyaXggaWRl bnRpdHlNYXRyaXg7Ci0KKyAgICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCB6b29tTWF0cml4OworICAg IHpvb21NYXRyaXguc2NhbGUzZChtX3RleHR1cmVab29tLCBtX3RleHR1cmVab29tLCAxLjApOwog ICAgIHsKICAgICAgICAgVFJBQ0VfRVZFTlQoIkNDTGF5ZXJUcmVlSG9zdDo6dXBkYXRlTGF5ZXJz OjpjYWxjRHJhd0V0YyIsIHRoaXMsIDApOwotICAgICAgICBDQ0xheWVyVHJlZUhvc3RDb21tb246 OmNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zQW5kVmlzaWJpbGl0eShyb290TGF5ZXIsIHJvb3RMYXll ciwgaWRlbnRpdHlNYXRyaXgsIGlkZW50aXR5TWF0cml4LCBtX3VwZGF0ZUxpc3QsIHJvb3RSZW5k ZXJTdXJmYWNlLT5sYXllckxpc3QoKSwgbGF5ZXJSZW5kZXJlckNhcGFiaWxpdGllcygpLm1heFRl eHR1cmVTaXplKTsKKyAgICAgICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVEcmF3 VHJhbnNmb3Jtc0FuZFZpc2liaWxpdHkocm9vdExheWVyLCByb290TGF5ZXIsIHpvb21NYXRyaXgs IHpvb21NYXRyaXgsIG1fdXBkYXRlTGlzdCwgcm9vdFJlbmRlclN1cmZhY2UtPmxheWVyTGlzdCgp LCBsYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzKCkubWF4VGV4dHVyZVNpemUpOwogICAgIH0KIAog ICAgIHBhaW50TGF5ZXJDb250ZW50cyhtX3VwZGF0ZUxpc3QpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0Lmgg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJl ZUhvc3QuaAppbmRleCA0ODg5NDg0NDFkODVjMDlkMGI0MTc3NWZhMmFjNjVjZTMzY2NlYTA3Li5m ODUzMjM5Yzg0MWQ1NWQwMmRlYjRhZTE2Y2UwZGI1MmNhN2VhN2E5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3Qu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xh eWVyVHJlZUhvc3QuaApAQCAtMTMwLDYgKzEzMCw3IEBAIHB1YmxpYzoKICAgICBpbnQgZnJhbWVO dW1iZXIoKSBjb25zdCB7IHJldHVybiBtX2ZyYW1lTnVtYmVyOyB9CiAKICAgICB2b2lkIGludmFs aWRhdGVSb290TGF5ZXJSZWN0KGNvbnN0IEludFJlY3QmIGRpcnR5UmVjdCk7CisgICAgdm9pZCBz ZXRUZXh0dXJlWm9vbShjb25zdCBkb3VibGUpOwogCiAgICAgY29uc3QgTGF5ZXJSZW5kZXJlckNh cGFiaWxpdGllcyYgbGF5ZXJSZW5kZXJlckNhcGFiaWxpdGllcygpIGNvbnN0OwogCkBAIC0xNDgs NiArMTQ5LDcgQEAgcHVibGljOgogICAgIHZvaWQgc2V0Vmlld3BvcnQoY29uc3QgSW50U2l6ZSYg dmlld3BvcnRTaXplLCBjb25zdCBJbnRTaXplJiBjb250ZW50c1NpemUsIGNvbnN0IEludFBvaW50 JiBzY3JvbGxQb3NpdGlvbik7CiAKICAgICBjb25zdCBJbnRTaXplJiB2aWV3cG9ydFNpemUoKSBj b25zdCB7IHJldHVybiBtX3ZpZXdwb3J0U2l6ZTsgfQorICAgIGRvdWJsZSB0ZXh0dXJlWm9vbSgp IGNvbnN0IHsgcmV0dXJuIG1fdGV4dHVyZVpvb207IH0KICAgICBUZXh0dXJlTWFuYWdlciogY29u dGVudHNUZXh0dXJlTWFuYWdlcigpIGNvbnN0OwogCiAgICAgdm9pZCBzZXRWaXNpYmxlKGJvb2wp OwpAQCAtMTg3LDYgKzE4OSw3IEBAIHByaXZhdGU6CiAgICAgQ0NTZXR0aW5ncyBtX3NldHRpbmdz OwogCiAgICAgSW50U2l6ZSBtX3ZpZXdwb3J0U2l6ZTsKKyAgICBkb3VibGUgbV90ZXh0dXJlWm9v bTsKICAgICBib29sIG1fdmlzaWJsZTsKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdEltcGwuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVI b3N0SW1wbC5jcHAKaW5kZXggOWRlMjAyOWRlYzdkMjMzZWNlZWFhY2E1NjY2NzM5MTkzMzRlZDNk YS4uYjg0NzVkYzQ5YzMzOTcyOTQzYWU0NGQ5YWY0NDc0N2FmZDA2MmNiNiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVI b3N0SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vY2MvQ0NMYXllclRyZWVIb3N0SW1wbC5jcHAKQEAgLTQ3LDYgKzQ3LDcgQEAgQ0NMYXllclRy ZWVIb3N0SW1wbDo6Q0NMYXllclRyZWVIb3N0SW1wbChjb25zdCBDQ1NldHRpbmdzJiBzZXR0aW5n cykKICAgICA6IG1fc291cmNlRnJhbWVOdW1iZXIoLTEpCiAgICAgLCBtX2ZyYW1lTnVtYmVyKDAp CiAgICAgLCBtX3NldHRpbmdzKHNldHRpbmdzKQorICAgICwgbV90ZXh0dXJlWm9vbSgxLjApCiB7 CiB9CiAKQEAgLTE1NSw0ICsxNTYsMTAgQEAgdm9pZCBDQ0xheWVyVHJlZUhvc3RJbXBsOjpzZXRW aWV3cG9ydChjb25zdCBJbnRTaXplJiB2aWV3cG9ydFNpemUpCiAgICAgICAgIG1fbGF5ZXJSZW5k ZXJlci0+dmlld3BvcnRDaGFuZ2VkKCk7CiB9CiAKK3ZvaWQgQ0NMYXllclRyZWVIb3N0SW1wbDo6 c2V0VGV4dHVyZVpvb20oZG91YmxlIHpvb20pCit7CisgICAgbV90ZXh0dXJlWm9vbSA9IHpvb207 CisgICAgbV9sYXllclJlbmRlcmVyLT5zZXRUZXh0dXJlWm9vbSh6b29tKTsKK30KKwogfQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NM YXllclRyZWVIb3N0SW1wbC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vY2MvQ0NMYXllclRyZWVIb3N0SW1wbC5oCmluZGV4IDUzYTRkNTUyNGE1N2I4MzVkZTRk ODMyMGVhYzBjNjQ5ZTY2MDYyYmYuLjM3OTZlZjBlY2Y4NWRkNDEyNDI2ZDQzZDBlYWFkZDhkOGUy M2M1M2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL2NjL0NDTGF5ZXJUcmVlSG9zdEltcGwuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3RJbXBsLmgKQEAgLTc1LDYgKzc1 LDggQEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRWaWV3cG9ydChjb25zdCBJbnRTaXplJiB2aWV3 cG9ydFNpemUpOwogICAgIGNvbnN0IEludFNpemUmIHZpZXdwb3J0U2l6ZSgpIGNvbnN0IHsgcmV0 dXJuIG1fdmlld3BvcnRTaXplOyB9CisgICAgdm9pZCBzZXRUZXh0dXJlWm9vbShkb3VibGUpOwor ICAgIGRvdWJsZSB0ZXh0dXJlWm9vbSgpIGNvbnN0IHsgcmV0dXJuIG1fdGV4dHVyZVpvb207IH0K IAogcHJvdGVjdGVkOgogICAgIGV4cGxpY2l0IENDTGF5ZXJUcmVlSG9zdEltcGwoY29uc3QgQ0NT ZXR0aW5ncyYpOwpAQCAtODYsNiArODgsNyBAQCBwcml2YXRlOgogICAgIFJlZlB0cjxDQ0xheWVy SW1wbD4gbV9yb290TGF5ZXJJbXBsOwogICAgIENDU2V0dGluZ3MgbV9zZXR0aW5nczsKICAgICBJ bnRTaXplIG1fdmlld3BvcnRTaXplOworICAgIGRvdWJsZSBtX3RleHR1cmVab29tOwogfTsKIAog fTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmNwcAppbmRleCA5M2FhOTRmZjE3Y2UyMzYy MzBhN2I4NmNkMjBjZTcwNTMxOGY4MmJjLi5jNGQ2N2VlY2JjYmZlNzNiNzVhNzFhNzUzZWFlMDk3 MjUyODIzMDA3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRlcm5hbHMuY3BwCkBAIC0yNDIsNiAr MjQyLDE2IEBAIHZvaWQgSW50ZXJuYWxzOjpzZXRGb3JjZUNvbXBvc2l0aW5nTW9kZShEb2N1bWVu dCogZG9jdW1lbnQsIGJvb2wgZW5hYmxlZCwgRXhjZXB0CiAgICAgZG9jdW1lbnQtPnNldHRpbmdz KCktPnNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKGVuYWJsZWQpOwogfQogCit2b2lkIEludGVybmFs czo6c2V0Wm9vbUFuaW1hdG9yU2NhbGUoRG9jdW1lbnQgKmRvY3VtZW50LCBkb3VibGUgc2NhbGUs IEV4Y2VwdGlvbkNvZGUmIGVjKQoreworICAgIGlmICghZG9jdW1lbnQgfHwgIWRvY3VtZW50LT5z ZXR0aW5ncygpKSB7CisgICAgICAgIGVjID0gSU5WQUxJRF9BQ0NFU1NfRVJSOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgZG9jdW1lbnQtPnNldHRpbmdzKCktPnNldFpvb21BbmltYXRv clNjYWxlKHNjYWxlKTsKK30KKwogdm9pZCBJbnRlcm5hbHM6OnNldFBhc3N3b3JkRWNob0VuYWJs ZWQoRG9jdW1lbnQqIGRvY3VtZW50LCBib29sIGVuYWJsZWQsIEV4Y2VwdGlvbkNvZGUmIGVjKQog ewogICAgIGlmICghZG9jdW1lbnQgfHwgIWRvY3VtZW50LT5zZXR0aW5ncygpKSB7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5oIGIvU291cmNlL1dlYkNvcmUv dGVzdGluZy9JbnRlcm5hbHMuaAppbmRleCA4ZjMxNGExODk1Mzc2OWQ0Y2Y0YTA1MDMzNjZiOTlm MTJmNzhlZDQ2Li42MGRiZDk5MWY2ZmU1ZGFmMTZhZWM4MDFhNDhkY2QzOGZkMWZkYjI1IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmgKQEAgLTc3LDYgKzc3LDcgQEAgcHVibGljOgogICAg IFBhc3NSZWZQdHI8UmFuZ2U+IG1hcmtlclJhbmdlRm9yTm9kZShOb2RlKiwgdW5zaWduZWQsIEV4 Y2VwdGlvbkNvZGUmKTsKIAogICAgIHZvaWQgc2V0Rm9yY2VDb21wb3NpdGluZ01vZGUoRG9jdW1l bnQqLCBib29sIGVuYWJsZWQsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICB2b2lkIHNldFpvb21Bbmlt YXRvclNjYWxlKERvY3VtZW50KiwgZG91YmxlIHNjYWxlLCBFeGNlcHRpb25Db2RlJik7CiAKICAg ICB2b2lkIHNldFBhc3N3b3JkRWNob0VuYWJsZWQoRG9jdW1lbnQqLCBib29sIGVuYWJsZWQsIEV4 Y2VwdGlvbkNvZGUmKTsKICAgICB2b2lkIHNldFBhc3N3b3JkRWNob0R1cmF0aW9uSW5TZWNvbmRz KERvY3VtZW50KiwgZG91YmxlIGR1cmF0aW9uSW5TZWNvbmRzLCBFeGNlcHRpb25Db2RlJik7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5pZGwgYi9Tb3VyY2Uv V2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5pZGwKaW5kZXggMmM0OWNhZGEyNGEwNjRjMmYxNzM0 MjJiYzg4Y2RhZmZlZGM4YzBhMy4uM2E3YTRkOTZhYzgyMGUyYzQxODQ2ZDcwNDhhMGM4ZjI3ZmY5 ZjIyZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRlcm5hbHMuaWRsCisr KyBiL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmlkbApAQCAtNTEsNiArNTEsNyBA QCBtb2R1bGUgd2luZG93IHsKICAgICAgICAgUmFuZ2UgbWFya2VyUmFuZ2VGb3JOb2RlKGluIE5v ZGUgbm9kZSwgaW4gdW5zaWduZWQgbG9uZyBpbmRleCkgcmFpc2VzKERPTUV4Y2VwdGlvbik7CiAK ICAgICAgICAgdm9pZCBzZXRGb3JjZUNvbXBvc2l0aW5nTW9kZShpbiBEb2N1bWVudCBkb2N1bWVu dCwgaW4gYm9vbGVhbiBlbmFibGVkKSByYWlzZXMoRE9NRXhjZXB0aW9uKTsKKyAgICAgICAgdm9p ZCBzZXRab29tQW5pbWF0b3JTY2FsZShpbiBEb2N1bWVudCBkb2N1bWVudCwgaW4gZG91YmxlIHNj YWxlKSByYWlzZXMoRE9NRXhjZXB0aW9uKTsKIAogICAgICAgICB2b2lkIHNldFBhc3N3b3JkRWNo b0VuYWJsZWQoaW4gRG9jdW1lbnQgZG9jdW1lbnQsIGluIGJvb2xlYW4gZW5hYmxlZCkgcmFpc2Vz KERPTUV4Y2VwdGlvbik7CiAgICAgICAgIHZvaWQgc2V0UGFzc3dvcmRFY2hvRHVyYXRpb25JblNl Y29uZHMoaW4gRG9jdW1lbnQgZG9jdW1lbnQsIGluIGRvdWJsZSBkdXJhdGlvbkluU2Vjb25kcykg cmFpc2VzKERPTUV4Y2VwdGlvbik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJWaWV3SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3 SW1wbC5jcHAKaW5kZXggNmMyOTJjMWQ1ODA4NTg5ZWNkZTA1YWMyY2NhZDc0ZWE1YTI1NTJiMS4u MWQ5MGE1Yjk1ZTAwZWU2NzVhMWQwNDdlNWUxNGNjNzdjM2E1OTQyNiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcApAQCAtMTgyMyw2ICsxODIzLDkgQEAgZG91 YmxlIFdlYlZpZXdJbXBsOjp6b29tTGV2ZWwoKQogCiBkb3VibGUgV2ViVmlld0ltcGw6OnNldFpv b21MZXZlbChib29sIHRleHRPbmx5LCBkb3VibGUgem9vbUxldmVsKQogeworICAgIGlmIChtX2xh eWVyVHJlZUhvc3QpCisgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+c2V0VGV4dHVyZVpvb20oMS4w KTsKKwogICAgIGlmICh6b29tTGV2ZWwgPCBtX21pbmltdW1ab29tTGV2ZWwpCiAgICAgICAgIG1f em9vbUxldmVsID0gbV9taW5pbXVtWm9vbUxldmVsOwogICAgIGVsc2UgaWYgKHpvb21MZXZlbCA+ IG1fbWF4aW11bVpvb21MZXZlbCkKQEAgLTI1NjMsMTAgKzI1NjYsOSBAQCB2b2lkIFdlYlZpZXdJ bXBsOjpzZXRSb290R3JhcGhpY3NMYXllcihHcmFwaGljc0xheWVyKiBsYXllcikKIAogdm9pZCBX ZWJWaWV3SW1wbDo6c2V0Um9vdExheWVyTmVlZHNEaXNwbGF5KCkKIHsKLSNpZiBVU0UoVEhSRUFE RURfQ09NUE9TSVRJTkcpCiAgICAgaWYgKG1fbGF5ZXJUcmVlSG9zdCkKLSAgICAgICAgbV9sYXll clRyZWVIb3N0LT5zZXROZWVkc0NvbW1pdEFuZFJlZHJhdygpOwotI2Vsc2UKKyAgICAgICAgbV9s YXllclRyZWVIb3N0LT5zZXRUZXh0dXJlWm9vbShtX3BhZ2UtPnNldHRpbmdzKCktPnpvb21Bbmlt YXRvclNjYWxlKCkpOworI2lmICFVU0UoVEhSRUFERURfQ09NUE9TSVRJTkcpCiAgICAgbV9jbGll bnQtPnNjaGVkdWxlQ29tcG9zaXRlKCk7CiAjZW5kaWYKIH0K 106732 2011-09-08 07:25:56 -0700 2011-09-08 13:30:10 -0700 Patch bug-66472-20110908102332.patch text/plain 18713 wjmaclean ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA5MDk2MjQ3MWRhM2VjZjViYjU2OGMwNmYzZDcxYWQzNDBjYjdlMTEwLi5jYWNjNmU4 ODZhMGFiMDg1YzNmNTk5OWM2NGI4ZDZhZjdlNDViZDgzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAK KzIwMTEtMDktMDggIFcuIEphbWVzIE1hY0xlYW4gIDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgor CisgICAgICAgIFtjaHJvbWl1bV0gQWRkIGJhY2tlbmQgY29tcG9zaXRvciBzdXBwb3J0IGZvciBy ZXNjYWxpbmcgKHpvb21pbmcpIHRleHR1cmVzIGR1cmluZyB6b29tIGFuaW1hdGlvbi4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY2NDcyCisKKyAgICAg ICAgSW5pdGlhbCB0ZXN0cyBmb3Igem9vbUFuaW1hdG9yQ2hyb21pdW0gYmFja2VuZC4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHBsYXRmb3JtL2No cm9taXVtLWdwdS1saW51eC9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFuaW1h dG9yLXNjYWxlLXRlc3QtZXhwZWN0ZWQucG5nOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9j aHJvbWl1bS1ncHUtbGludXgvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmlt YXRvci1zY2FsZS10ZXN0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0v Y2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10ZXN0Lmh0bWw6IEFkZGVk LgorCiAyMDExLTA5LTA4ICBDc2FiYSBPc3p0cm9nb27DoWMgIDxvc3N5QHdlYmtpdC5vcmc+CiAK ICAgICAgICAgW1F0XSBDb3VwbGUgb2YgdGVzdHMgaGF2ZSBkaWZmZXJlbnQgcmVzdWx0cyBvbiA2 NCBiaXQgYW5kL29yIGluIGRlYnVnIG1vZGUgY29tcGFyZWQgdG8gMzIgYml0IGFuZC9vciByZWxl YXNlIG1vZGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWdwdS1s aW51eC9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29tLWFuaW1hdG9yLXNjYWxlLXRl c3QtZXhwZWN0ZWQucG5nIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tZ3B1LWxpbnV4 L3BsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC1l eHBlY3RlZC5wbmcKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjBlZTJhY2I1NDNjNjk1MzMyMWE1MTlhMDkxZThmNDE3 NDg0YjY2MwpHSVQgYmluYXJ5IHBhdGNoCmxpdGVyYWwgMjg2MQp6Y21lQVNATj8ob2xIeWB1VkJx IWlhMHl+eVV7K3ZZVjJhPmkwKlopPWheaGxBJUBXcyRsSGBvazxtfT9vVCF5cVgKelYtdGc8bHIj JU5Mangwd3EqVWBYbFQ/Y3xBVCYweUcmZVZ+YlpodjJuU3BfOHpvKDAxTlg0QURIIWdCSUlTUX5p CnpgayNzSnNxdE51XyVKcTw8QDMhbUdpUW8zRndGaF9qZSgoSXhuS2tYZ0pCfnBnTWpjVFY+QSUo cT1iIzx6Y3FOegp6eT89OUYhUSE5aXpPZ1dAZHZLNzZwQFVQMHA8JXs+UU8wTj41Sig5KFgzbCll JWZRaDhYZilNfj05dGw5VzM8UXwKaSU+fD5tMERDVUAlaCsqKmNlUnEtIVh2PTtGTjNHNnBVWE9A Z2VDeCg5Xyk0aQoKbGl0ZXJhbCAwCkhjbVY/ZDAwMDAxCgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvcGxhdGZvcm0vY2hyb21pdW0tZ3B1LWxpbnV4L3BsYXRmb3JtL2Nocm9taXVtL2NvbXBvc2l0 aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9w bGF0Zm9ybS9jaHJvbWl1bS1ncHUtbGludXgvcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcv em9vbS1hbmltYXRvci1zY2FsZS10ZXN0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44YjEzNzg5 MTc5MWZlOTY5MjdhZDc4ZTY0YjBhYWQ3YmRlZDA4YmRjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tZ3B1LWxpbnV4L3BsYXRmb3JtL2Nocm9taXVtL2Nv bXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC1leHBlY3RlZC50eHQKQEAgLTAsMCAr MSBAQAorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3Np dGluZy96b29tLWFuaW1hdG9yLXNjYWxlLXRlc3QuaHRtbCBiL0xheW91dFRlc3RzL3BsYXRmb3Jt L2Nocm9taXVtL2NvbXBvc2l0aW5nL3pvb20tYW5pbWF0b3Itc2NhbGUtdGVzdC5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjMwMDc0YjI2MDEwODUwMTI2Njc4ZjhlMWNjZjdjNzk2NWZhOTM0ZDcKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9jb21wb3NpdGluZy96b29t LWFuaW1hdG9yLXNjYWxlLXRlc3QuaHRtbApAQCAtMCwwICsxLDI0IEBACis8aHRtbD4KKyAgPGhl YWQ+CisgICAgPHNjcmlwdD4KKyAgICAgICAgaWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICAg ICAgICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0Rm9yY2VDb21wb3NpdGluZ01vZGUoZG9jdW1lbnQs IHRydWUpOworICAgICAgICAgICAgd2luZG93LmludGVybmFscy5zZXRab29tQW5pbWF0b3JTY2Fs ZShkb2N1bWVudCwgMS4yNSk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgd2luZG93LmxheW91dFRlc3RDb250cm9sbGVy LmR1bXBBc1RleHQodHJ1ZSk7CisgICAgICAgIH0KKworICAgICAgICBmdW5jdGlvbiBkb1Rlc3Qo KSB7CisgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYUJveCIpLnN0eWxlLmJh Y2tncm91bmRDb2xvciA9ICJncmVlbiI7CisgICAgICAgIH0KKworICAgICAgICB3aW5kb3cuYWRk RXZlbnRMaXN0ZW5lcigibG9hZCIsIGRvVGVzdCwgZmFsc2UpOworICAgIDwvc2NyaXB0PgorICA8 L2hlYWQ+Cis8Ym9keT4KKyAgPCEtLSAgICBJZiBzdWNjZXNzZnVsLCB0aGUgYm94IHNob3VsZCBl bmxhcmdlIHRvIGJlIDEyNXgxMjUgYXQgKDEyNSwxMjUpLgorICAgIC0tPgorICA8ZGl2IGlkPSJh Qm94IiBzdHlsZT0id2lkdGg6MTAwcHg7IGhlaWdodDoxMDBweDsgcG9zaXRpb246YWJzb2x1dGU7 IGxlZnQ6MTAwcHg7IHRvcDoxMDBweDsgYmFja2dyb3VuZC1jb2xvcjojRkYwMDAwIj48L2Rpdj4K KzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBi L1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAwZTFkNzMzZGNhMzA4YzRhMmI1MWVmYzE5 M2FkMTQ0ZTM0NjNhOWMzLi5kODkzZTAwNzVhODZiMTRlZjViNjRjNWRjY2JhOWRiZDZlNjY0ZjZh IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzkgQEAKKzIwMTEtMDktMDggIFcuIEphbWVzIE1hY0xl YW4gIDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gQWRkIGJh Y2tlbmQgY29tcG9zaXRvciBzdXBwb3J0IGZvciByZXNjYWxpbmcgKHpvb21pbmcpIHRleHR1cmVz IGR1cmluZyB6b29tIGFuaW1hdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTY2NDcyCisKKyAgICAgICAgVGhpcyBwYXRjaCBjb250YWlucyBwbHVt YmluZyBmcm9tIEludGVybmFscyB0byBXZWJWaWV3SW1wbCB0aGF0IGNhbiBiZSByZW1vdmVkCisg ICAgICAgIGF0IGEgbGF0ZXIgdGltZSB3aGVuIHRoZSB6b29tIGFuaW1hdG9yIGNvZGUgaXMgY29t cGxldGUuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg VGVzdDogcGxhdGZvcm0vY2hyb21pdW0vY29tcG9zaXRpbmcvem9vbS1hbmltYXRvci1zY2FsZS10 ZXN0Lmh0bWwKKworICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6U2V0dGluZ3M6OlNldHRpbmdzKToKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6CisgICAg ICAgIChXZWJDb3JlOjpTZXR0aW5nczo6c2V0Wm9vbUFuaW1hdG9yU2NhbGUpOgorICAgICAgICAo V2ViQ29yZTo6U2V0dGluZ3M6Onpvb21BbmltYXRvclNjYWxlKToKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwOgorICAgICAgICAo V2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpMYXllclJlbmRlcmVyQ2hyb21pdW0pOgor ICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzSW50ZXJu YWwpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpzZXRa b29tQW5pbWF0b3JTY2FsZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Y2MvQ0NMYXllclRyZWVIb3N0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNDTGF5ZXJUcmVlSG9z dDo6Q0NMYXllclRyZWVIb3N0KToKKyAgICAgICAgKFdlYkNvcmU6OkNDTGF5ZXJUcmVlSG9zdDo6 Y29tbWl0VG8pOgorICAgICAgICAoV2ViQ29yZTo6Q0NMYXllclRyZWVIb3N0OjpzZXRab29tQW5p bWF0b3JTY2FsZSk6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OnVwZGF0ZUxh eWVycyk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRy ZWVIb3N0Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXll clRyZWVIb3N0SW1wbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3RJbXBs OjpzZXRab29tQW5pbWF0b3JTY2FsZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vY2MvQ0NMYXllclRyZWVIb3N0SW1wbC5oOgorICAgICAgICAqIHRlc3RpbmcvSW50ZXJu YWxzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkludGVybmFsczo6c2V0Wm9vbUFuaW1hdG9yU2Nh bGUpOgorICAgICAgICAqIHRlc3RpbmcvSW50ZXJuYWxzLmg6CisgICAgICAgICogdGVzdGluZy9J bnRlcm5hbHMuaWRsOgorCiAyMDExLTA5LTA4ICBBbGV4YW5kZXIgUGF2bG92ICA8YXBhdmxvdkBj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgc3RyaXAgdHJhaWxpbmcgd2hpdGVz cGFjZSBpbiB0aGUgV2ViIEluc3BlY3RvciBmcm9udGVuZCAoKi5qcyBhbmQgKi5jc3MpLgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wYWdlL1NldHRpbmdzLmNwcAppbmRleCAxMDI4YjdiYmYzNGFjNDIzZjMzZWExMjdhMjY4N2Q2 N2QyNzYxN2ExLi4yZGMxZmJiNzUyMjFlY2E1MmY2M2QzYjNlMTk1MGNjMDMzYzI2NmYwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL1NldHRpbmdzLmNwcApAQCAtMjE2LDYgKzIxNiw3IEBAIFNldHRpbmdzOjpTZXR0 aW5ncyhQYWdlKiBwYWdlKQogICAgICwgbV9tZWRpYVBsYXliYWNrQWxsb3dzSW5saW5lKHRydWUp CiAgICAgLCBtX3Bhc3N3b3JkRWNob0VuYWJsZWQoZmFsc2UpCiAgICAgLCBtX2xvYWRzSW1hZ2Vz QXV0b21hdGljYWxseVRpbWVyKHRoaXMsICZTZXR0aW5nczo6bG9hZHNJbWFnZXNBdXRvbWF0aWNh bGx5VGltZXJGaXJlZCkKKyAgICAsIG1fem9vbUFuaW1hdG9yU2NhbGUoMSkKIHsKICAgICAvLyBB IEZyYW1lIG1heSBub3QgaGF2ZSBiZWVuIGNyZWF0ZWQgeWV0LCBzbyB3ZSBpbml0aWFsaXplIHRo ZSBBdG9taWNTdHJpbmcgCiAgICAgLy8gaGFzaCBiZWZvcmUgdHJ5aW5nIHRvIHVzZSBpdC4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaCBiL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvU2V0dGluZ3MuaAppbmRleCA1MTUxOWFkNWFhMzBiYWZkOTNjMzhhNWE3ZDM1YjFjOTRk ZWNhZjBkLi5hOWI0YWM1MDExMWViZDZjNTk1OTIzY2VjOGM4OWEwYTQxNzc4NzRhIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGFnZS9TZXR0aW5ncy5oCkBAIC00MzcsNyArNDM3LDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK IAogICAgICAgICB2b2lkIHNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKGJvb2wgZmxhZykgeyBtX2Zv cmNlQ29tcG9zaXRpbmdNb2RlID0gZmxhZzsgfQogICAgICAgICBib29sIGZvcmNlQ29tcG9zaXRp bmdNb2RlKCkgeyByZXR1cm4gbV9mb3JjZUNvbXBvc2l0aW5nTW9kZTsgfQotICAgICAgICAKKwor ICAgICAgICB2b2lkIHNldFpvb21BbmltYXRvclNjYWxlKGRvdWJsZSBzY2FsZSkgeyBtX3pvb21B bmltYXRvclNjYWxlID0gc2NhbGU7IH0KKyAgICAgICAgZG91YmxlIHpvb21BbmltYXRvclNjYWxl KCkgeyByZXR1cm4gbV96b29tQW5pbWF0b3JTY2FsZTsgfQorCiAgICAgICAgIHZvaWQgc2V0U2hv dWxkSW5qZWN0VXNlclNjcmlwdHNJbkluaXRpYWxFbXB0eURvY3VtZW50KGJvb2wgZmxhZykgeyBt X3Nob3VsZEluamVjdFVzZXJTY3JpcHRzSW5Jbml0aWFsRW1wdHlEb2N1bWVudCA9IGZsYWc7IH0K ICAgICAgICAgYm9vbCBzaG91bGRJbmplY3RVc2VyU2NyaXB0c0luSW5pdGlhbEVtcHR5RG9jdW1l bnQoKSB7IHJldHVybiBtX3Nob3VsZEluamVjdFVzZXJTY3JpcHRzSW5Jbml0aWFsRW1wdHlEb2N1 bWVudDsgfQogCkBAIC01OTYsNiArNTk5LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAg ICBzdGF0aWMgYm9vbCBnQVZGb3VuZGF0aW9uRW5hYmxlZDsKICNlbmRpZgogCisgICAgICAgIGRv dWJsZSBtX3pvb21BbmltYXRvclNjYWxlOworCiAjaWYgVVNFKFNBRkFSSV9USEVNRSkKICAgICAg ICAgc3RhdGljIGJvb2wgZ1Nob3VsZFBhaW50TmF0aXZlQ29udHJvbHM7CiAjZW5kaWYKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVu ZGVyZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCmluZGV4IDExNDY1ZGMzMTgzNzI4ZTZlYTJl MWYxZDBkMDMyNDMwNzEzOGQ3ODAuLjVkNWU0YzU4Y2EyYTM4YTA3MDU3YzBkZDZlOTc5ZTRjYzky OWFmMjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcApAQCAtMTYzLDYg KzE2Myw3IEBAIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6TGF5ZXJSZW5kZXJlckNocm9taXVtKEND TGF5ZXJUcmVlSG9zdCogb3duZXIsCiAgICAgLCBtX293bmVySW1wbChvd25lckltcGwpCiAgICAg LCBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlKDApCiAgICAgLCBtX29mZnNjcmVlbkZyYW1lYnVmZmVy SWQoMCkKKyAgICAsIG1fem9vbUFuaW1hdG9yU2NhbGUoMSkKICAgICAsIG1fY29udGV4dChjb250 ZXh0KQogICAgICwgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSgwKQogICAgICwgbV9zaGFyZWRHZW9t ZXRyeVF1YWQoRmxvYXRSZWN0KC0wLjVmLCAtMC41ZiwgMS4wZiwgMS4wZikpCkBAIC0yOTQsMTMg KzI5NSwxNCBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6ZHJhd0xheWVyc0ludGVybmFs KCkKICAgICBDQ0xheWVyTGlzdCByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0OwogICAgIHJlbmRlclN1 cmZhY2VMYXllckxpc3QuYXBwZW5kKHJvb3REcmF3TGF5ZXIpOwogCi0gICAgVHJhbnNmb3JtYXRp b25NYXRyaXggaWRlbnRpdHlNYXRyaXg7CisgICAgVHJhbnNmb3JtYXRpb25NYXRyaXggem9vbU1h dHJpeDsKKyAgICB6b29tTWF0cml4LnNjYWxlM2QobV96b29tQW5pbWF0b3JTY2FsZSwgbV96b29t QW5pbWF0b3JTY2FsZSwgMSk7CiAgICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSA9IHJvb3REcmF3 TGF5ZXItPnJlbmRlclN1cmZhY2UoKTsKICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5jbGVh ckxheWVyTGlzdCgpOwogCiAgICAgewogICAgICAgICBUUkFDRV9FVkVOVCgiTGF5ZXJSZW5kZXJl ckNocm9taXVtOjpkcmF3TGF5ZXJzSW50ZXJuYWw6OmNhbGNEcmF3RXRjIiwgdGhpcywgMCk7Ci0g ICAgICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9ybXNBbmRW aXNpYmlsaXR5KHJvb3REcmF3TGF5ZXIsIHJvb3REcmF3TGF5ZXIsIGlkZW50aXR5TWF0cml4LCBp ZGVudGl0eU1hdHJpeCwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCwgbV9kZWZhdWx0UmVuZGVyU3Vy ZmFjZS0+bGF5ZXJMaXN0KCksICZtX2xheWVyU29ydGVyLCBtX2NhcGFiaWxpdGllcy5tYXhUZXh0 dXJlU2l6ZSk7CisgICAgICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1Ry YW5zZm9ybXNBbmRWaXNpYmlsaXR5KHJvb3REcmF3TGF5ZXIsIHJvb3REcmF3TGF5ZXIsIHpvb21N YXRyaXgsIHpvb21NYXRyaXgsIHJlbmRlclN1cmZhY2VMYXllckxpc3QsIG1fZGVmYXVsdFJlbmRl clN1cmZhY2UtPmxheWVyTGlzdCgpLCAmbV9sYXllclNvcnRlciwgbV9jYXBhYmlsaXRpZXMubWF4 VGV4dHVyZVNpemUpOwogICAgIH0KIAogICAgIC8vIFRoZSBHTCB2aWV3cG9ydCBjb3ZlcnMgdGhl IGVudGlyZSB2aXNpYmxlIGFyZWEsIGluY2x1ZGluZyB0aGUgc2Nyb2xsYmFycy4KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVy ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v TGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggMGYxMDM2NmYyZTlmM2RlZWU3MTI3NGRiNmRk NmEzNzRiN2VjNWE3MC4uYWZiZTIyZDg4ZTBkZWZlYzFlZjBlMWNhYWEwMTRiOWViOWJiNDY4YyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5 ZXJSZW5kZXJlckNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKQEAgLTExMCw2ICsxMTAsOCBAQCBw dWJsaWM6CiAgICAgLy8gcHV0cyBiYWNrYnVmZmVyIG9uc2NyZWVuCiAgICAgdm9pZCBwcmVzZW50 KCk7CiAKKyAgICB2b2lkIHNldFpvb21BbmltYXRvclNjYWxlKGRvdWJsZSBmYWN0b3IpIHsgbV96 b29tQW5pbWF0b3JTY2FsZSA9IGZhY3RvcjsgfQorCiAgICAgdW5zaWduZWQgY3JlYXRlTGF5ZXJU ZXh0dXJlKCk7CiAgICAgdm9pZCBkZWxldGVMYXllclRleHR1cmUodW5zaWduZWQpOwogCkBAIC0x OTYsNiArMTk4LDcgQEAgcHJpdmF0ZToKIAogICAgIENDUmVuZGVyU3VyZmFjZSogbV9jdXJyZW50 UmVuZGVyU3VyZmFjZTsKICAgICB1bnNpZ25lZCBtX29mZnNjcmVlbkZyYW1lYnVmZmVySWQ7Cisg ICAgZG91YmxlIG1fem9vbUFuaW1hdG9yU2NhbGU7CiAKICAgICAvLyBTdG9yZSB2YWx1ZXMgdGhh dCBhcmUgc2hhcmVkIGJldHdlZW4gaW5zdGFuY2VzIG9mIGVhY2ggbGF5ZXIgdHlwZQogICAgIC8v IGFzc29jaWF0ZWQgd2l0aCB0aGlzIGluc3RhbmNlIG9mIHRoZSBjb21wb3NpdG9yLiBTaW5jZSB0 aGVyZSBjYW4gYmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCmluZGV4IGYxMjQ5NWI2 NTVmMzljN2Y2OWE0ZjcwYzI0ZDc3ZjgxMzA4MTRjYmIuLjU2Mzg0NWQxZTIyZGVmNWM3ODQyOTUz ZTE5MzY2ZDNiZTg3MTM2YjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcApAQCAt NTQsNiArNTQsNyBAQCBDQ0xheWVyVHJlZUhvc3Q6OkNDTGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJl ZUhvc3RDbGllbnQqIGNsaWVudCwgY29uc3QgQ0NTZXR0aW5ncwogICAgICwgbV9mcmFtZU51bWJl cigwKQogICAgICwgbV9ub25Db21wb3NpdGVkQ29udGVudEhvc3QoTm9uQ29tcG9zaXRlZENvbnRl bnRIb3N0OjpjcmVhdGUobV9jbGllbnQtPmNyZWF0ZVJvb3RMYXllclBhaW50ZXIoKSkpCiAgICAg LCBtX3NldHRpbmdzKHNldHRpbmdzKQorICAgICwgbV96b29tQW5pbWF0b3JTY2FsZSgxKQogICAg ICwgbV92aXNpYmxlKHRydWUpCiB7CiB9CkBAIC0xMTUsNiArMTE2LDcgQEAgdm9pZCBDQ0xheWVy VHJlZUhvc3Q6OmNvbW1pdFRvKENDTGF5ZXJUcmVlSG9zdEltcGwqIGhvc3RJbXBsKQogICAgIG1f dXBkYXRlTGlzdC5jbGVhcigpOwogCiAgICAgaG9zdEltcGwtPnNldFZpc2libGUobV92aXNpYmxl KTsKKyAgICBob3N0SW1wbC0+c2V0Wm9vbUFuaW1hdG9yU2NhbGUobV96b29tQW5pbWF0b3JTY2Fs ZSk7CiAgICAgaG9zdEltcGwtPnNldFZpZXdwb3J0KHZpZXdwb3J0U2l6ZSgpKTsKIAogICAgIC8v IFN5bmNocm9uaXplIHRyZWVzLCBpZiBvbmUgZXhpc3RzIGF0IGFsbC4uLgpAQCAtMTgyLDYgKzE4 NCwxNiBAQCBjb25zdCBMYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzJiBDQ0xheWVyVHJlZUhvc3Q6 OmxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMoKSBjbwogICAgIHJldHVybiBtX3Byb3h5LT5sYXll clJlbmRlcmVyQ2FwYWJpbGl0aWVzKCk7CiB9CiAKK3ZvaWQgQ0NMYXllclRyZWVIb3N0OjpzZXRa b29tQW5pbWF0b3JTY2FsZShkb3VibGUgem9vbSkKK3sKKyAgICBib29sIHpvb21DaGFuZ2VkID0g bV96b29tQW5pbWF0b3JTY2FsZSAhPSB6b29tOworCisgICAgbV96b29tQW5pbWF0b3JTY2FsZSA9 IHpvb207CisKKyAgICBpZiAoem9vbUNoYW5nZWQpCisgICAgICAgIHNldE5lZWRzQ29tbWl0QW5k UmVkcmF3KCk7Cit9CisKIHZvaWQgQ0NMYXllclRyZWVIb3N0OjpzZXROZWVkc0NvbW1pdEFuZFJl ZHJhdygpCiB7CiAjaWYgVVNFKFRIUkVBREVEX0NPTVBPU0lUSU5HKQpAQCAtMjc4LDExICsyOTAs MTEgQEAgdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnVwZGF0ZUxheWVycyhMYXllckNocm9taXVtKiBy b290TGF5ZXIpCiAgICAgUmVuZGVyU3VyZmFjZUNocm9taXVtKiByb290UmVuZGVyU3VyZmFjZSA9 IHJvb3RMYXllci0+cmVuZGVyU3VyZmFjZSgpOwogICAgIHJvb3RSZW5kZXJTdXJmYWNlLT5jbGVh ckxheWVyTGlzdCgpOwogCi0gICAgVHJhbnNmb3JtYXRpb25NYXRyaXggaWRlbnRpdHlNYXRyaXg7 Ci0KKyAgICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCB6b29tTWF0cml4OworICAgIHpvb21NYXRyaXgu c2NhbGUzZChtX3pvb21BbmltYXRvclNjYWxlLCBtX3pvb21BbmltYXRvclNjYWxlLCAxKTsKICAg ICB7CiAgICAgICAgIFRSQUNFX0VWRU5UKCJDQ0xheWVyVHJlZUhvc3Q6OnVwZGF0ZUxheWVyczo6 Y2FsY0RyYXdFdGMiLCB0aGlzLCAwKTsKLSAgICAgICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpj YWxjdWxhdGVEcmF3VHJhbnNmb3Jtc0FuZFZpc2liaWxpdHkocm9vdExheWVyLCByb290TGF5ZXIs IGlkZW50aXR5TWF0cml4LCBpZGVudGl0eU1hdHJpeCwgbV91cGRhdGVMaXN0LCByb290UmVuZGVy U3VyZmFjZS0+bGF5ZXJMaXN0KCksIGxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMoKS5tYXhUZXh0 dXJlU2l6ZSk7CisgICAgICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1Ry YW5zZm9ybXNBbmRWaXNpYmlsaXR5KHJvb3RMYXllciwgcm9vdExheWVyLCB6b29tTWF0cml4LCB6 b29tTWF0cml4LCBtX3VwZGF0ZUxpc3QsIHJvb3RSZW5kZXJTdXJmYWNlLT5sYXllckxpc3QoKSwg bGF5ZXJSZW5kZXJlckNhcGFiaWxpdGllcygpLm1heFRleHR1cmVTaXplKTsKICAgICB9CiAKICAg ICBwYWludExheWVyQ29udGVudHMobV91cGRhdGVMaXN0KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVI b3N0LmgKaW5kZXggNDg4OTQ4NDQxZDg1YzA5ZDBiNDE3NzVmYTJhYzY1Y2UzM2NjZWEwNy4uYzZl ZDg1ZmE5ZDJkNTFhMjA3OTZmOWEyM2Y4ODZmNzYxOWMwYWQ2YyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXll clRyZWVIb3N0LmgKQEAgLTEzMCw2ICsxMzAsNyBAQCBwdWJsaWM6CiAgICAgaW50IGZyYW1lTnVt YmVyKCkgY29uc3QgeyByZXR1cm4gbV9mcmFtZU51bWJlcjsgfQogCiAgICAgdm9pZCBpbnZhbGlk YXRlUm9vdExheWVyUmVjdChjb25zdCBJbnRSZWN0JiBkaXJ0eVJlY3QpOworICAgIHZvaWQgc2V0 Wm9vbUFuaW1hdG9yU2NhbGUoZG91YmxlKTsKIAogICAgIGNvbnN0IExheWVyUmVuZGVyZXJDYXBh YmlsaXRpZXMmIGxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMoKSBjb25zdDsKIApAQCAtMTg3LDYg KzE4OCw3IEBAIHByaXZhdGU6CiAgICAgQ0NTZXR0aW5ncyBtX3NldHRpbmdzOwogCiAgICAgSW50 U2l6ZSBtX3ZpZXdwb3J0U2l6ZTsKKyAgICBkb3VibGUgbV96b29tQW5pbWF0b3JTY2FsZTsKICAg ICBib29sIG1fdmlzaWJsZTsKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdEltcGwuY3BwIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0SW1w bC5jcHAKaW5kZXggOWRlMjAyOWRlYzdkMjMzZWNlZWFhY2E1NjY2NzM5MTkzMzRlZDNkYS4uNzA4 MmQ2NWIzYjRiNTlmMzYyODEyY2I3ODcxMTgwNDk3NTc3MzUwMCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0SW1w bC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NMYXllclRyZWVIb3N0SW1wbC5jcHAKQEAgLTE1NSw0ICsxNTUsOSBAQCB2b2lkIENDTGF5ZXJU cmVlSG9zdEltcGw6OnNldFZpZXdwb3J0KGNvbnN0IEludFNpemUmIHZpZXdwb3J0U2l6ZSkKICAg ICAgICAgbV9sYXllclJlbmRlcmVyLT52aWV3cG9ydENoYW5nZWQoKTsKIH0KIAordm9pZCBDQ0xh eWVyVHJlZUhvc3RJbXBsOjpzZXRab29tQW5pbWF0b3JTY2FsZShkb3VibGUgem9vbSkKK3sKKyAg ICBtX2xheWVyUmVuZGVyZXItPnNldFpvb21BbmltYXRvclNjYWxlKHpvb20pOworfQorCiB9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9D Q0xheWVyVHJlZUhvc3RJbXBsLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3RJbXBsLmgKaW5kZXggNTNhNGQ1NTI0YTU3YjgzNWRl NGQ4MzIwZWFjMGM2NDllNjYwNjJiZi4uMDUyZjI2MDliYjQ0MzBkMGNlYjEyNGEzOGUwZDY2N2Zi OWFjYTEwYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vY2MvQ0NMYXllclRyZWVIb3N0SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdEltcGwuaApAQCAtNzUsNiAr NzUsNyBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHNldFZpZXdwb3J0KGNvbnN0IEludFNpemUmIHZp ZXdwb3J0U2l6ZSk7CiAgICAgY29uc3QgSW50U2l6ZSYgdmlld3BvcnRTaXplKCkgY29uc3QgeyBy ZXR1cm4gbV92aWV3cG9ydFNpemU7IH0KKyAgICB2b2lkIHNldFpvb21BbmltYXRvclNjYWxlKGRv dWJsZSk7CiAKIHByb3RlY3RlZDoKICAgICBleHBsaWNpdCBDQ0xheWVyVHJlZUhvc3RJbXBsKGNv bnN0IENDU2V0dGluZ3MmKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50 ZXJuYWxzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmNwcAppbmRleCBm ZTE4MDA1MmU4MzljNmU4NTkzNmI2NWMyZDc0MGFlYmFiMThlZDk1Li4wNGVjOWVmNTM3NDhiOWFk NzRmZWU4MDY2NmNmMTUwZGIxODBlYTNiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS90ZXN0 aW5nL0ludGVybmFscy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRlcm5hbHMu Y3BwCkBAIC0yNDMsNiArMjQzLDE2IEBAIHZvaWQgSW50ZXJuYWxzOjpzZXRGb3JjZUNvbXBvc2l0 aW5nTW9kZShEb2N1bWVudCogZG9jdW1lbnQsIGJvb2wgZW5hYmxlZCwgRXhjZXB0CiAgICAgZG9j dW1lbnQtPnNldHRpbmdzKCktPnNldEZvcmNlQ29tcG9zaXRpbmdNb2RlKGVuYWJsZWQpOwogfQog Cit2b2lkIEludGVybmFsczo6c2V0Wm9vbUFuaW1hdG9yU2NhbGUoRG9jdW1lbnQgKmRvY3VtZW50 LCBkb3VibGUgc2NhbGUsIEV4Y2VwdGlvbkNvZGUmIGVjKQoreworICAgIGlmICghZG9jdW1lbnQg fHwgIWRvY3VtZW50LT5zZXR0aW5ncygpKSB7CisgICAgICAgIGVjID0gSU5WQUxJRF9BQ0NFU1Nf RVJSOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgZG9jdW1lbnQtPnNldHRpbmdzKCkt PnNldFpvb21BbmltYXRvclNjYWxlKHNjYWxlKTsKK30KKwogdm9pZCBJbnRlcm5hbHM6OnNldFBh c3N3b3JkRWNob0VuYWJsZWQoRG9jdW1lbnQqIGRvY3VtZW50LCBib29sIGVuYWJsZWQsIEV4Y2Vw dGlvbkNvZGUmIGVjKQogewogICAgIGlmICghZG9jdW1lbnQgfHwgIWRvY3VtZW50LT5zZXR0aW5n cygpKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5oIGIv U291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRlcm5hbHMuaAppbmRleCBkNjQ0ZDBhOTkwZjEyYWIz ZDc4ZjQwNjRhYWRmMjBhNzE1ODNlZjlhLi4xMzQzN2UxZWRhNDA1Nzk0ODJlYWU4N2M3NDg3MTY3 ZjRkNzBmNjUyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmgKQEAgLTc3LDYgKzc3LDcg QEAgcHVibGljOgogICAgIFBhc3NSZWZQdHI8UmFuZ2U+IG1hcmtlclJhbmdlRm9yTm9kZShOb2Rl KiwgdW5zaWduZWQsIEV4Y2VwdGlvbkNvZGUmKTsKIAogICAgIHZvaWQgc2V0Rm9yY2VDb21wb3Np dGluZ01vZGUoRG9jdW1lbnQqLCBib29sIGVuYWJsZWQsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICB2 b2lkIHNldFpvb21BbmltYXRvclNjYWxlKERvY3VtZW50KiwgZG91YmxlIHNjYWxlLCBFeGNlcHRp b25Db2RlJik7CiAKICAgICB2b2lkIHNldFBhc3N3b3JkRWNob0VuYWJsZWQoRG9jdW1lbnQqLCBi b29sIGVuYWJsZWQsIEV4Y2VwdGlvbkNvZGUmKTsKICAgICB2b2lkIHNldFBhc3N3b3JkRWNob0R1 cmF0aW9uSW5TZWNvbmRzKERvY3VtZW50KiwgZG91YmxlIGR1cmF0aW9uSW5TZWNvbmRzLCBFeGNl cHRpb25Db2RlJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFs cy5pZGwgYi9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFscy5pZGwKaW5kZXggZDc4YTdk NDIyZTkzMjQzOTExZDQ5ZDFkZWEwMmYwNWRiMTMyZTJlZC4uNWUyMzFjY2Q1MzE4OTU5NGVhZDRj NmYwOGNiNzMwOWQ0MmJlNzM2OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvdGVzdGluZy9J bnRlcm5hbHMuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxzLmlkbApA QCAtNTEsNiArNTEsNyBAQCBtb2R1bGUgd2luZG93IHsKICAgICAgICAgUmFuZ2UgbWFya2VyUmFu Z2VGb3JOb2RlKGluIE5vZGUgbm9kZSwgaW4gdW5zaWduZWQgbG9uZyBpbmRleCkgcmFpc2VzKERP TUV4Y2VwdGlvbik7CiAKICAgICAgICAgdm9pZCBzZXRGb3JjZUNvbXBvc2l0aW5nTW9kZShpbiBE b2N1bWVudCBkb2N1bWVudCwgaW4gYm9vbGVhbiBlbmFibGVkKSByYWlzZXMoRE9NRXhjZXB0aW9u KTsKKyAgICAgICAgdm9pZCBzZXRab29tQW5pbWF0b3JTY2FsZShpbiBEb2N1bWVudCBkb2N1bWVu dCwgaW4gZG91YmxlIHNjYWxlKSByYWlzZXMoRE9NRXhjZXB0aW9uKTsKIAogICAgICAgICB2b2lk IHNldFBhc3N3b3JkRWNob0VuYWJsZWQoaW4gRG9jdW1lbnQgZG9jdW1lbnQsIGluIGJvb2xlYW4g ZW5hYmxlZCkgcmFpc2VzKERPTUV4Y2VwdGlvbik7CiAgICAgICAgIHZvaWQgc2V0UGFzc3dvcmRF Y2hvRHVyYXRpb25JblNlY29uZHMoaW4gRG9jdW1lbnQgZG9jdW1lbnQsIGluIGRvdWJsZSBkdXJh dGlvbkluU2Vjb25kcykgcmFpc2VzKERPTUV4Y2VwdGlvbik7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nCmluZGV4IGE3NGQxZTg5NTdlYWEwMzljNzViZDcyNzk2NjhhNGU3ZjkzNTA0ZDMuLmJhM2Nj MWZmNjNlOGQ3OWIxM2YyYTY1ODU4YzM2YTU0OWU5NWVmMTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDktMDggIFcuIEphbWVzIE1hY0xlYW4gIDx3 am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gQWRkIGJhY2tlbmQg Y29tcG9zaXRvciBzdXBwb3J0IGZvciByZXNjYWxpbmcgKHpvb21pbmcpIHRleHR1cmVzIGR1cmlu ZyB6b29tIGFuaW1hdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTY2NDcyCisKKyAgICAgICAgVGhpcyBwYXRjaCBjb250YWlucyBwbHVtYmluZyBm cm9tIEludGVybmFscyB0byBXZWJWaWV3SW1wbCB0aGF0IGNhbiBiZSByZW1vdmVkCisgICAgICAg IGF0IGEgbGF0ZXIgdGltZSB3aGVuIHRoZSB6b29tIGFuaW1hdG9yIGNvZGUgaXMgY29tcGxldGUu CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBzcmMv V2ViVmlld0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6c2V0Wm9vbUxl dmVsKToKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6OnNldFJvb3RMYXllck5lZWRzRGlz cGxheSk6CisKIDIwMTEtMDktMDcgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4KIAog ICAgICAgICBGcmFtZUxvYWRlcjo6YWRkRXh0cmFGaWVsZHNUb1JlcXVlc3QgY2FuIGNyYXNoIHdo ZW4gY2FsbGVkIGZyb20gb3IgYWZ0ZXIgRnJhbWVMb2FkZXI6OmRldGFjaEZyb21QYXJlbnQKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcCBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcAppbmRleCA2YzI5MmMxZDU4 MDg1ODllY2RlMDVhYzJjY2FkNzRlYTVhMjU1MmIxLi41NzViN2MzOTk0NGQyNGYwMDRlODNlMTMw ZTYwODUyMjEzOWI4N2JmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJWaWV3SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0lt cGwuY3BwCkBAIC0xODIzLDYgKzE4MjMsOSBAQCBkb3VibGUgV2ViVmlld0ltcGw6Onpvb21MZXZl bCgpCiAKIGRvdWJsZSBXZWJWaWV3SW1wbDo6c2V0Wm9vbUxldmVsKGJvb2wgdGV4dE9ubHksIGRv dWJsZSB6b29tTGV2ZWwpCiB7CisgICAgaWYgKG1fbGF5ZXJUcmVlSG9zdCkKKyAgICAgICAgbV9s YXllclRyZWVIb3N0LT5zZXRab29tQW5pbWF0b3JTY2FsZSgxKTsKKwogICAgIGlmICh6b29tTGV2 ZWwgPCBtX21pbmltdW1ab29tTGV2ZWwpCiAgICAgICAgIG1fem9vbUxldmVsID0gbV9taW5pbXVt Wm9vbUxldmVsOwogICAgIGVsc2UgaWYgKHpvb21MZXZlbCA+IG1fbWF4aW11bVpvb21MZXZlbCkK QEAgLTI1NjMsNiArMjU2Niw4IEBAIHZvaWQgV2ViVmlld0ltcGw6OnNldFJvb3RHcmFwaGljc0xh eWVyKEdyYXBoaWNzTGF5ZXIqIGxheWVyKQogCiB2b2lkIFdlYlZpZXdJbXBsOjpzZXRSb290TGF5 ZXJOZWVkc0Rpc3BsYXkoKQogeworICAgIGlmIChtX2xheWVyVHJlZUhvc3QpCisgICAgICAgIG1f bGF5ZXJUcmVlSG9zdC0+c2V0Wm9vbUFuaW1hdG9yU2NhbGUobV9wYWdlLT5zZXR0aW5ncygpLT56 b29tQW5pbWF0b3JTY2FsZSgpKTsKICNpZiBVU0UoVEhSRUFERURfQ09NUE9TSVRJTkcpCiAgICAg aWYgKG1fbGF5ZXJUcmVlSG9zdCkKICAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXROZWVkc0Nv bW1pdEFuZFJlZHJhdygpOwo=