50833 2010-12-10 11:32:49 -0800 [chromium] Add support to compositor to composite to offscreen texture. 2011-01-04 17:50:29 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Other OS X 10.5 RESOLVED FIXED P2 Normal --- 51345 1 wjmaclean wjmaclean abarth backer commit-queue enne eric jamesr kbr rjkroege vangelis webkit.review.bot oldest_to_newest 320266 0 wjmaclean 2010-12-10 11:32:49 -0800 [chromium] Add support to compositor to composite to offscreen texture. 320271 1 76228 wjmaclean 2010-12-10 11:36:41 -0800 Created attachment 76228 Patch 320288 2 wjmaclean 2010-12-10 11:47:36 -0800 *** The initial patch for this issue is posted for comments/discussion only, and is not intended to represent the final interface. It has not been marked for review. *** Please add names to CC list who may have important input to this discussion. The attached patch is experimental code which causes the compositor to composite into an offscreen texture (attached to a RenderSurfaceChromium object attached to m_rootLayer in LayerRendererChromium). It is meant to show a possible method for extending the compositor to do this, and includes sample code in WebViewImpl to actually invoke the code for testing. * Comments on the approach? * Have I missed anything that might break compositing? So far testing has been limited to http://webkit.org/blog-files/3d-transforms/poster-circle.html http://webkit.org/blog/386/3d-transforms/ http://peter.sh/2010/06/chromium-now-features-gpu-acceleration-and-css-3d-transforms/ Interface functions definitely need careful consideration, and I would like your feedback on what is appropriate. Questions to answer: * is one off-screen texture enough, or should double-buffering of textures be an option? * is it sufficient to export the texture ID, or should the entire containing RenderSurfaceChromium object be returned? * Should LayerRendererChromium::copyOffscreenTextureToDisplay() be retained in the final interface? 320297 3 wjmaclean 2010-12-10 12:02:13 -0800 (In reply to comment #1) > Created an attachment (id=76228) [details] > Patch Please ignore the line m_rootContentRect.setY(15); I forgot to take this out ... it works fine without. 320301 4 76232 wjmaclean 2010-12-10 12:05:27 -0800 Created attachment 76232 Patch, with some extraneous lines removed. 321117 5 wjmaclean 2010-12-13 07:52:28 -0800 James R. - When updating this morning, I see you are working along similar lines ... can we coordinate our efforts? Please let me know how you would like to proceed. 321182 6 jamesr 2010-12-13 10:03:43 -0800 What's the motivation for this functionality? 321209 7 wjmaclean 2010-12-13 10:18:29 -0800 (In reply to comment #6) > What's the motivation for this functionality? It's for "Baklava" ... we discussed this with KBR and Vangelis when we were down (invited you too, but you were unable to attend). It's to provide browser-level compositing of of a touch-screen keyboard, plus possibly slide-out omnibox/button bar. 321730 8 76232 vangelis 2010-12-14 00:44:47 -0800 Comment on attachment 76232 Patch, with some extraneous lines removed. View in context: https://bugs.webkit.org/attachment.cgi?id=76232&action=review Generally looks fine. I think if this were a real implementation you would eliminate the copyOffscreenTextureToDisplay call and you would allocate the additional texture for the default render surface only when the compositor is told to render off screen. Otherwise you would just render straight to the display backbuffer as it's done today. I also think there might be some additional merging that needs to happen with jamesr's texture manager CL. > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:201 > + if (m_rootLayer->m_renderSurface.get()) you don't have to include the .get(). It's enough to test m_rootLayer->m_renderSurface . > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:294 > + if (!m_rootLayer->m_renderSurface.get()) remove .get() > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:666 > + m_renderOffscreen = compositeOffscreen; nit: Ideally the member name and the variable name should match. I think I prefer compositeOffscreen to renderOffscreen > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:696 > + GLC(m_context, m_context->colorMask(true, true, true, false)); I don't know that masking is necessary as it should have been done when you drew into the default render surface so hopefully the alpha channel is ok. > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:702 > + contentLayerValues->shaderMatrixLocation(), contentLayerValues->shaderAlphaLocation()); You need to use m_textureLayerShaderMatrixLocation and m_textureLayerShaderAlphaLocation here. Also, after Jamesr patch landed, RenderSurfaceChromium has its own draw method I believe. > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:796 > + // But, if rendering to offscreen texture, we reverse our sense of 'upside down'. This seems a little strange. I can see how maybe you don't need to render upside down when rendering to the default render surface but I don't see why you need to flip all the other render surfaces too. 322056 9 76549 wjmaclean 2010-12-14 11:17:34 -0800 Created attachment 76549 Patch 322064 10 wjmaclean 2010-12-14 11:26:49 -0800 (In reply to comment #8) > (From update of attachment 76232 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=76232&action=review > > Generally looks fine. I think if this were a real implementation you would eliminate the copyOffscreenTextureToDisplay call and you would allocate the additional texture for the default render surface only when the compositor is told to render off screen. Otherwise you would just render straight to the display backbuffer as it's done today. > > I also think there might be some additional merging that needs to happen with jamesr's texture manager CL. This is done in the current patch. Most of the changes are in copyOffscreenTextureToDisplay(), which will disappear once this patch is past "discussion" and into "review". > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:201 > > + if (m_rootLayer->m_renderSurface.get()) > > you don't have to include the .get(). It's enough to test m_rootLayer->m_renderSurface . Fixed. > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:294 > > + if (!m_rootLayer->m_renderSurface.get()) > > remove .get() Fixed. > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:666 > > + m_renderOffscreen = compositeOffscreen; > > nit: Ideally the member name and the variable name should match. I think I prefer compositeOffscreen to renderOffscreen Agrred, I thought of this too after submitting the previous patches. Fixed. > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:696 > > + GLC(m_context, m_context->colorMask(true, true, true, false)); > > I don't know that masking is necessary as it should have been done when you drew into the default render surface so hopefully the alpha channel is ok. Removed. > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:702 > > + contentLayerValues->shaderMatrixLocation(), contentLayerValues->shaderAlphaLocation()); > > You need to use m_textureLayerShaderMatrixLocation and m_textureLayerShaderAlphaLocation here. Also, after Jamesr patch landed, RenderSurfaceChromium has its own draw method I believe. Redundant, as new patch uses RenderSurfaceChromium::draw() which looks after this. > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:796 > > + // But, if rendering to offscreen texture, we reverse our sense of 'upside down'. > > This seems a little strange. I can see how maybe you don't need to render upside down when rendering to the default render surface but I don't see why you need to flip all the other render surfaces too. I'm guessing that the final drawing of the texture also gets flipped, so we need to do this so everything comes out right in the end. Without it, clipping on pages like http://webkit.org/blog/386/3d-transforms/ and http://peter.sh/2010/06/chromium-now-features-gpu-acceleration-and-css-3d-transforms/ are upside-down and translate the wrong way. I'd like to submit this as a patch for review/commit, so please let me know if it's ready (assuming I'll remove copyOffscreenTextureToDisplay() and the two lines of test code in WebViewImpl.cpp first ...). 322072 11 wjmaclean 2010-12-14 11:34:05 -0800 (In reply to comment #10) > (In reply to comment #8) > > (From update of attachment 76232 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=76232&action=review > > > > ... and you would allocate the additional texture for the default render surface only when the compositor is told to render off screen. Otherwise you would just render straight to the display backbuffer as it's done today. Forgot to talk about these two points: - at present, I rely on the call to prepareContentsTexture() in useRenderSurface() to allocate the texture, and this only happens when drawLayers() is invoked(). - if m_compositeOffscreen is false, then compositing is done in the same way as at present, including compositing directly to the backbuffer. 322641 12 76549 vangelis 2010-12-15 09:47:35 -0800 Comment on attachment 76549 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=76549&action=review James, a couple more comments but overall I think it looks good. > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:303 > + m_rootLayer->m_renderSurface->m_contentRect = IntRect(0, 0, m_rootLayerTextureWidth, m_rootLayerTextureHeight); I think we can move the m_rootLayer's render surface creation to ::prepareToDrawLayers() and set the m_contentRect only when the m_rootLayerTextureWidth changes. > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:339 > + m_rootLayer->m_renderSurface->m_scissorRect = rootScissorRect; // Do I need this? No, you don't need to set the scissor rect here. The render surface's scissor rect is the scissor rect that needs to be applied before drawing the completed surface to its own parent surface. > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:786 > + renderingUpsideDown = !renderingUpsideDown; I believe the correct logic here would be: if (m_currentRenderSurface == m_defaultRenderSurface && ! m_compositeOffscreen) // flip the scissor else // don't flip the scissor In other words, I don't think you should be flipping the scissor for all non-root renderSurface's when you're rendering offscreen. > WebCore/platform/graphics/chromium/LayerRendererChromium.h:162 > + bool m_compositeOffscreen; Need to provide a default value for this in the constructor. 323154 13 76767 wjmaclean 2010-12-16 06:54:47 -0800 Created attachment 76767 Patch 323156 14 wjmaclean 2010-12-16 06:57:23 -0800 (In reply to comment #12) > (From update of attachment 76549 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=76549&action=review > > James, a couple more comments but overall I think it looks good. > > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:303 > > + m_rootLayer->m_renderSurface->m_contentRect = IntRect(0, 0, m_rootLayerTextureWidth, m_rootLayerTextureHeight); > > I think we can move the m_rootLayer's render surface creation to ::prepareToDrawLayers() and set the m_contentRect only when the m_rootLayerTextureWidth changes. I agree ... this makes more sense than testing again in drawLayers(). > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:339 > > + m_rootLayer->m_renderSurface->m_scissorRect = rootScissorRect; // Do I need this? > > No, you don't need to set the scissor rect here. The render surface's scissor rect is the scissor rect that needs to be applied before drawing the completed surface to its own parent surface. Thanks - removed. > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:786 > > + renderingUpsideDown = !renderingUpsideDown; > > I believe the correct logic here would be: > > if (m_currentRenderSurface == m_defaultRenderSurface && ! m_compositeOffscreen) > // flip the scissor > else > // don't flip the scissor > > In other words, I don't think you should be flipping the scissor for all non-root renderSurface's when you're rendering offscreen. Fixed - I've made this change and tested it, and it works as expected. > > WebCore/platform/graphics/chromium/LayerRendererChromium.h:162 > > + bool m_compositeOffscreen; > > Need to provide a default value for this in the constructor. Fixed. I've submitted the new patch, and asked for a review. 323862 15 76767 jamesr 2010-12-17 10:38:59 -0800 Comment on attachment 76767 Patch R=me 323876 16 76767 commit-queue 2010-12-17 10:56:44 -0800 Comment on attachment 76767 Patch Clearing flags on attachment: 76767 Committed r74278: <http://trac.webkit.org/changeset/74278> 323877 17 commit-queue 2010-12-17 10:56:50 -0800 All reviewed patches have been landed. Closing bug. 324514 18 jamesr 2010-12-20 12:48:44 -0800 Reverted r74278 for reason: [chromium] Causes many layout tests to crash Committed r74358: <http://trac.webkit.org/changeset/74358> 325008 19 77114 wjmaclean 2010-12-21 08:00:42 -0800 Created attachment 77114 Patch 325012 20 wjmaclean 2010-12-21 08:06:44 -0800 (In reply to comment #19) > Created an attachment (id=77114) [details] > Patch I've attached a revised patch which I've manually tested with the WebGL body-viewer demo. I've attempted to run the full test suite: the update/build commands had problems (see below), but I manually built debug versions of chrome, test_shell and DumpRenderTree and ran: $ ./Tools/Scripts/new-run-webkit-tests --chromium --debug --platform=chromium-gpu and I got these results: canvas/philip/tests/2d.imageData.get.source.outside.html -> unexpected pass canvas/philip/tests/2d.shadow.transform.2.html -> unexpected pass fast/canvas/canvas-scale-fillPath-shadow.html -> unexpected pass fast/canvas/canvas-scale-fillRect-shadow.html -> unexpected pass fast/canvas/canvas-scale-strokePath-shadow.html -> unexpected pass 22727 tests ran as expected, 5 didn't: Expected to fail, but passed: (5) canvas/philip/tests/2d.imageData.get.source.outside.html canvas/philip/tests/2d.shadow.transform.2.html fast/canvas/canvas-scale-fillPath-shadow.html fast/canvas/canvas-scale-fillRect-shadow.html fast/canvas/canvas-scale-strokePath-shadow.html Now, I need to determine whether this is in fact a clean set of tests, or if the failure of the update/build commands means it is in fact not to be trusted. Thoughts? The build/update command failures are: ------------------------------------------------------------------------------- ./Tools/Scripts/update-webkit --chromium If I do this on branch 'master' on a freshly checkout-out repo (updated once with git-pull), I get Updating OpenSource Unable to determine upstream SVN information from working tree history Died at ./Tools/Scripts/update-webkit line 132 ./Tools/Scripts/build-webkit --chromium --debug If I try to run this on a branch containing my patch (keeping in mind I couldn't get the update command to run), I get make -fMakefile.chromium -j16 BUILDTYPE=Debug all make: Makefile.chromium: No such file or directory make: *** No rule to make target `Makefile.chromium'. Stop. ------------------------------------------------------------------------------- 325610 21 77114 vangelis 2010-12-22 11:46:39 -0800 Comment on attachment 77114 Patch The adjustment to avoid the crash from the previous patch looks good. 325621 22 kbr 2010-12-22 12:04:54 -0800 (In reply to comment #20) > (In reply to comment #19) > > Created an attachment (id=77114) [details] [details] > > Patch > > I've attached a revised patch which I've manually tested with the WebGL body-viewer demo. > > I've attempted to run the full test suite: the update/build commands had problems (see below), but I manually built debug versions of chrome, test_shell and DumpRenderTree and ran: > > $ ./Tools/Scripts/new-run-webkit-tests --chromium --debug --platform=chromium-gpu > > and I got these results: > > canvas/philip/tests/2d.imageData.get.source.outside.html -> unexpected pass > canvas/philip/tests/2d.shadow.transform.2.html -> unexpected pass > fast/canvas/canvas-scale-fillPath-shadow.html -> unexpected pass > fast/canvas/canvas-scale-fillRect-shadow.html -> unexpected pass > fast/canvas/canvas-scale-strokePath-shadow.html -> unexpected pass > 22727 tests ran as expected, 5 didn't: > > > Expected to fail, but passed: (5) > canvas/philip/tests/2d.imageData.get.source.outside.html > canvas/philip/tests/2d.shadow.transform.2.html > fast/canvas/canvas-scale-fillPath-shadow.html > fast/canvas/canvas-scale-fillRect-shadow.html > fast/canvas/canvas-scale-strokePath-shadow.html I updated the GPU test expectations yesterday to expect that these five tests will pass, so this is fine. > Now, I need to determine whether this is in fact a clean set of tests, or if the failure of the update/build commands means it is in fact not to be trusted. > > Thoughts? > > The build/update command failures are: > ------------------------------------------------------------------------------- > > ./Tools/Scripts/update-webkit --chromium > > If I do this on branch 'master' on a freshly checkout-out repo (updated once with git-pull), I get > > Updating OpenSource > > Unable to determine upstream SVN information from working tree history > > Died at ./Tools/Scripts/update-webkit line 132 > > ./Tools/Scripts/build-webkit --chromium --debug > > If I try to run this on a branch containing my patch (keeping in mind I couldn't get the update command to run), I get > > make -fMakefile.chromium -j16 BUILDTYPE=Debug all > make: Makefile.chromium: No such file or directory > make: *** No rule to make target `Makefile.chromium'. Stop. > ------------------------------------------------------------------------------ I don't know why this is failing. I use a Subversion checkout of the WebKit tree configured within my Chromium repo per http://www.chromium.org/developers/contributing-to-webkit . 325622 23 77114 kbr 2010-12-22 12:10:03 -0800 Comment on attachment 77114 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=77114&action=review > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:682 > + } This logic only handles the transition from m_compositeOffscreen from false to true. What about the other direction? 325634 24 wjmaclean 2010-12-22 12:31:11 -0800 (In reply to comment #23) > (From update of attachment 77114 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=77114&action=review > > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:682 > > + } > > This logic only handles the transition from m_compositeOffscreen from false to true. What about the other direction? It should work both ways. m_compositeOffscreen is set to whatever the value of the argument to setCompositeOffscreen says, but can be overriden is m_rootLayer is false. Resources allocated going from false to true aren't necessarily de-allocated going from true to false, but it does go back to rendering direct to screen. Is that what you were wondering about? 325644 25 kbr 2010-12-22 12:47:55 -0800 (In reply to comment #24) > (In reply to comment #23) > > (From update of attachment 77114 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=77114&action=review > > > > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:682 > > > + } > > > > This logic only handles the transition from m_compositeOffscreen from false to true. What about the other direction? > > It should work both ways. m_compositeOffscreen is set to whatever the value of the argument to setCompositeOffscreen says, but can be overriden is m_rootLayer is false. > > Resources allocated going from false to true aren't necessarily de-allocated going from true to false, but it does go back to rendering direct to screen. > > Is that what you were wondering about? Yes, I was essentially wondering about the setting of the layer renderer for the root layer and any associated resources attached to the root layer. It would be good to clean up all of these resources upon the true -> false transition. What do you think about doing this work in this patch? 325679 26 77257 wjmaclean 2010-12-22 13:56:41 -0800 Created attachment 77257 Patch 325683 27 77257 wjmaclean 2010-12-22 13:59:47 -0800 Comment on attachment 77257 Patch This new patch releases resources immediately if conpositing to an offscreen texture is disabled. It does so by releasing the render surface associated with m_rootLayer. This will also free the corresponding texture. The render surface, without an underlying texture, will be re-created the next time LayerRendererChromium::prepareToDrawLayers() is invoked, and the subsequent call to drawLayers will draw directly to the screenwith no offscreen texture. 325702 28 77257 kbr 2010-12-22 14:36:15 -0800 Comment on attachment 77257 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=77257&action=review Thanks for the cleanup. Basically looks good. I'm happy to r+/cq+ as is, but if you're willing to submit a revised patch that's good too. Assuming you tested the new code path? > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:684 > + m_rootLayer->m_renderSurface.release(); You could use clear() here. Also, there's really no need to test m_renderSurface. 326063 29 wjmaclean 2010-12-23 07:04:42 -0800 (In reply to comment #28) > (From update of attachment 77257 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=77257&action=review > > Thanks for the cleanup. Basically looks good. I'm happy to r+/cq+ as is, but if you're willing to submit a revised patch that's good too. Assuming you tested the new code path? Yes, I did test it - since the patch as it stands doesn't invoke the offscreen rendering, I created a test-patch that turned offscreen compositing on at the start of WebViewImpl::doComposite() and then off again after copying the texture back to the screen. I ran this on the entire test suite. > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:684 > > + m_rootLayer->m_renderSurface.release(); > > You could use clear() here. Also, there's really no need to test m_renderSurface. I assume you mean clear() from LayerTexture? I thought about that and then shied away since (i) it requires another test to see if a texture is allocated, and then (ii) relies on the 'friend'-ness between LayerRendererChromium and RenderSurfaceChromium, as clear() is not exposed through the RenderSurfaceChromium interface. If this is considered OK, then I'm happy to use clear ... let me know. It's probably more efficient to use clear(). I get you comment about not needing to check m_renderSurface ... I keep thinking of it as a regular pointer :-) Although, I will need to check it in order to use clear(). I'm quite happy to iterate on the patch to make it better, so let me know what you think of my comments above. 326068 30 kbr 2010-12-23 07:48:57 -0800 (In reply to comment #29) > (In reply to comment #28) > > (From update of attachment 77257 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=77257&action=review > > > > Thanks for the cleanup. Basically looks good. I'm happy to r+/cq+ as is, but if you're willing to submit a revised patch that's good too. Assuming you tested the new code path? > > Yes, I did test it - since the patch as it stands doesn't invoke the offscreen rendering, I created a test-patch that turned offscreen compositing on at the start of WebViewImpl::doComposite() and then off again after copying the texture back to the screen. I ran this on the entire test suite. Great, sounds good. > > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:684 > > > + m_rootLayer->m_renderSurface.release(); > > > > You could use clear() here. Also, there's really no need to test m_renderSurface. > > I assume you mean clear() from LayerTexture? I thought about that and then shied away since (i) it requires another test to see if a texture is allocated, and then (ii) relies on the 'friend'-ness between LayerRendererChromium and RenderSurfaceChromium, as clear() is not exposed through the RenderSurfaceChromium interface. If this is considered OK, then I'm happy to use clear ... let me know. It's probably more efficient to use clear(). > > I get you comment about not needing to check m_renderSurface ... I keep thinking of it as a regular pointer :-) Although, I will need to check it in order to use clear(). > > I'm quite happy to iterate on the patch to make it better, so let me know what you think of my comments above. No, I simply meant calling: m_rootLayer->m_renderSurface.clear(); which has a void return value. 326077 31 wjmaclean 2010-12-23 08:07:57 -0800 (In reply to comment #30) > > No, I simply meant calling: > m_rootLayer->m_renderSurface.clear(); > which has a void return value. Ahh, OK. I didn't know about OwnPtr<>::clear(). Preparing/testing patch now ... 326269 32 77368 wjmaclean 2010-12-23 13:56:37 -0800 Created attachment 77368 Patch 326271 33 wjmaclean 2010-12-23 13:57:32 -0800 (In reply to comment #32) > Created an attachment (id=77368) [details] > Patch Revised as suggested, tested. 326372 34 77368 kbr 2010-12-23 17:00:27 -0800 Comment on attachment 77368 Patch Thanks. r=me 326488 35 77368 commit-queue 2010-12-24 00:08:09 -0800 Comment on attachment 77368 Patch Rejecting attachment 77368 from commit-queue. Failed to run "['./Tools/Scripts/webkit-patch', '--status-host=queues.webkit.org', '--bot-id=cr-jail-3', 'apply-attachment', '--no-update', '--non-interactive', 77368]" exit_code: 2 Last 500 characters of output: Hunk #5 succeeded at 645 (offset -46 lines). Hunk #6 succeeded at 713 (offset -46 lines). 1 out of 6 hunks FAILED -- saving rejects to file WebCore/platform/graphics/chromium/LayerRendererChromium.cpp.rej patching file WebCore/platform/graphics/chromium/LayerRendererChromium.h Hunk #1 succeeded at 87 (offset -1 lines). Hunk #2 succeeded at 164 (offset 6 lines). Failed to run "[u'/mnt/git/webkit-commit-queue/Tools/Scripts/svn-apply', u'--reviewer', u'Kenneth Russell', u'--force']" exit_code: 1 Full output: http://queues.webkit.org/results/7323134 326892 36 kbr 2010-12-26 09:43:11 -0800 It looks like you'll need to merge with top of tree and submit another patch. 327245 37 wjmaclean 2010-12-28 09:12:28 -0800 (In reply to comment #36) > It looks like you'll need to merge with top of tree and submit another patch. Merging isn't enough - Enne's patch moved things around a lot, so I've had to refactor this patch to match. However, Enne's patch seems to have changed something that I don't yet understand, as my re-factored patch seems to render black pages very nicely, but nothing else :-( I don't know if it's just my code to dump the rendered surfaces back to the display (during testing only), or if the behaviour of RenderLayerChromium::draw() has somehow changed, or something else. I'm looking at this now, but it may take a while to debug, esp. as I'm working from home and the GPU stuff doesn't display over NX (so far I'm just running new-run-webkit-tests and looking at the output for tests that fail). 327279 38 enne 2010-12-28 11:19:37 -0800 (In reply to comment #37) > (In reply to comment #36) > > It looks like you'll need to merge with top of tree and submit another patch. > > Merging isn't enough - Enne's patch moved things around a lot, so I've had to refactor this patch to match. However, Enne's patch seems to have changed something that I don't yet understand, as my re-factored patch seems to render black pages very nicely, but nothing else :-( I took a look through the last patch that you uploaded, but I don't see anything obvious that would interact poorly with the changes that I made. I modified how the root layer was being drawn, but that shouldn't have affected the surface on which it was being drawn. If there's something about that change that needs more explanation, feel free to ask here or send me an email or chat. > I don't know if it's just my code to dump the rendered surfaces back to the display (during testing only), or if the behaviour of RenderLayerChromium::draw() has somehow changed, or something else. I'm looking at this now, but it may take a while to debug, esp. as I'm working from home and the GPU stuff doesn't display over NX (so far I'm just running new-run-webkit-tests and looking at the output for tests that fail). You can use x11vnc to display GPU output remotely. On the host, run 'x11vnc -xkb -display :0' to share your X display. On the client, run 'vncviewer MACHINENAME:0' to connect to that host's display. It's slower than NX in general, but you at least get the GPU output. 327297 39 wjmaclean 2010-12-28 11:48:59 -0800 (In reply to comment #38) > (In reply to comment #37) > > (In reply to comment #36) > > > It looks like you'll need to merge with top of tree and submit another patch. > > > > Merging isn't enough - Enne's patch moved things around a lot, so I've had to refactor this patch to match. However, Enne's patch seems to have changed something that I don't yet understand, as my re-factored patch seems to render black pages very nicely, but nothing else :-( > > I took a look through the last patch that you uploaded, but I don't see anything obvious that would interact poorly with the changes that I made. I modified how the root layer was being drawn, but that shouldn't have affected the surface on which it was being drawn. Agreed ... there doesn't seem to be anything obvious. That being said, the one thing I did find is that when running the tests (new-run-webkit-tests) the call to WebViewImpl::doPixelReadbackToCanvas() generates an error from the call to imageBuffer->putPremultipliedImageData (line 1026-ish) complaining that assertions are failing in Skia color, namely SkASSERT(r < a); for example (see partial dump below ...), which suggests that the data in the buffer is no longer pre-multiplied (this test appears to run fine with chrome through VNC). I don't know if this is related to your patch or some other recent change, although it seems to be something that landed on Dec 23. If alpha = 0, then that might explain why DumpRenderTree is getting black images as well ... > If there's something about that change that needs more explanation, feel free to ask here or send me an email or chat. I'm going to keep looking at it, but may email/chat as I come up with questions. > > I don't know if it's just my code to dump the rendered surfaces back to the display (during testing only), or if the behaviour of RenderLayerChromium::draw() has somehow changed, or something else. I'm looking at this now, but it may take a while to debug, esp. as I'm working from home and the GPU stuff doesn't display over NX (so far I'm just running new-run-webkit-tests and looking at the output for tests that fail). > > You can use x11vnc to display GPU output remotely. On the host, run 'x11vnc -xkb -display :0' to share your X display. On the client, run 'vncviewer MACHINENAME:0' to connect to that host's display. It's slower than NX in general, but you at least get the GPU output. Thanks for this tip, although a bit slow, it does work! I can at least see that the on-screen version of the code does still seem to work OK. Actual output for compositing/animation/state-at-end-event-transform-layer.html: [4655:4655:434041820463:FATAL:SkColorPriv.h(216)] third_party/skia/include/core/SkColorPriv.h:216: failed assertion "r <= a" Backtrace: base::debug::StackTrace::StackTrace() [0x8a537e] logging::LogMessage::~LogMessage() [0x848cda] SkDebugf_FileLine() [0x9218c7] SkPackARGB32() [0xc7f6e3] WebCore::putImageData<>() [0xc81edf] WebCore::ImageBuffer::putPremultipliedImageData() [0xc8038d] WebKit::WebViewImpl::doPixelReadbackToCanvas() [0x488297] WebKit::WebViewImpl::paint() [0x488491] 327307 40 wjmaclean 2010-12-28 12:34:10 -0800 Another data point: when I run Tools/Scripts/new-run-webkit-tests --chromium --debug --platform=chromium-gpu then the failing tests (for example, fast/canvas/arc360.html) give an "actual" output of an all-black window, but if I run the same test directly in chrome (via VNC), I get what appears to be the correct output. I haven't check every single failing output manually, but everyone I've checked thus far follows this pattern ... So it seems that the same input is generating very different output for chrome and DumpRenderTree. Can anyone suggest what this might be due to? It only occurs when I composite to the offscreen texture, and then (immediately) copy that texture to the display. 327313 41 kbr 2010-12-28 12:50:32 -0800 (In reply to comment #40) > Another data point: when I run > > Tools/Scripts/new-run-webkit-tests --chromium --debug --platform=chromium-gpu > > then the failing tests (for example, fast/canvas/arc360.html) give an "actual" output of an all-black window, but if I run the same test directly in chrome (via VNC), I get what appears to be the correct output. I haven't check every single failing output manually, but everyone I've checked thus far follows this pattern ... > > So it seems that the same input is generating very different output for chrome and DumpRenderTree. > > Can anyone suggest what this might be due to? It only occurs when I composite to the offscreen texture, and then (immediately) copy that texture to the display. Have you checked to see whether this behavior was introduced with your patch? 327319 42 wjmaclean 2010-12-28 13:14:49 -0800 (In reply to comment #41) > (In reply to comment #40) > > Another data point: when I run > > > > Tools/Scripts/new-run-webkit-tests --chromium --debug --platform=chromium-gpu > > > > then the failing tests (for example, fast/canvas/arc360.html) give an "actual" output of an all-black window, but if I run the same test directly in chrome (via VNC), I get what appears to be the correct output. I haven't check every single failing output manually, but everyone I've checked thus far follows this pattern ... > > > > So it seems that the same input is generating very different output for chrome and DumpRenderTree. > > > > Can anyone suggest what this might be due to? It only occurs when I composite to the offscreen texture, and then (immediately) copy that texture to the display. > > Have you checked to see whether this behavior was introduced with your patch? I did not see this behaviour (with the same testing regimen) in this patch on or before Dec 23 (with or without compositing offscreen turned on). The current behaviour is that (1) with offscreen compositing turned on, and (2) with DumpRenderTree, the output of certain tests is all black. When just running with chrome (and the appropriate flags), everything looks normal (offscreen compositing on or off). I did have change putPremultipliedImageData to putUnmultipliedImageData to get DumpRenderTree (see comment above) to run without asserting on these tests. It does not give a black image for all tests (I'm assuming here that everything in fast/compositing gets tested when --platform=chromium-gpu is enabled?). I'll start looking at DumpRenderTree tomorrow to see what I can find. 327553 43 wjmaclean 2010-12-29 07:13:36 -0800 I've tried a simple experiment that seems to confirm that the problem I'm seeing involves the alpha values in the display buffer (see hack-patch below). The experiment involves, during readback of the display buffer (used presumably by DumpRenderTree during the GPU tests), forcing all the alpha values to 255. When I do this, I get the exact same test results I had on/before Dec 23. Why the alpha values are wrong only when rendering to an offscreen texture is yet to be determined. I'm guessing the display buffer ignores the alpha values, so things look right on the screen, but that DumpRenderTree multiplies by the alpha values before writing the PNG images used for comparison with the expected output images (creating a difference between manual observation and automated testing). Patch: diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp index 311b2c7..420e4d0 100644 --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp @@ -359,6 +359,13 @@ void LayerRendererChromium::getFramebufferPixels(void *pixels, const IntRect& re GLC(m_context.get(), m_context->readPixels(rect.x(), rect.y(), rect.width(), rect.height(), GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, pixels)); + + unsigned char* ptr = reinterpret_cast<unsigned char*>(pixels); + ptr += 3; // Offset to first alpha value. + // Set all alpha values to '1'. + unsigned numPixels = rect.width() * rect.height(); + for (unsigned i = 0; i < numPixels; ++i, ptr += 4) + *ptr = 255; } // FIXME: This method should eventually be replaced by a proper texture manager. 327583 44 wjmaclean 2010-12-29 09:12:45 -0800 OK, I think I've tracked down the change that is giving my patch difficulties. Before the root-layer tiling patch landed, the code that rendered the root layer use to call GLC(m_context.get(), m_context->colorMask(true, true, true, false)); before the call to LayerChromium::drawTexturedQuad and call GLC(m_context.get(), m_context->colorMask(true, true, true, true)); afterwards. The root-layer tiling patch masks off the alpha channel (makes the first call), but never turns it back on (the second call). The patch below turns it back on after the call to updateAndDrawRootLayer(), and restores the results of this patch (rendering to offscreen texture) without breaking any tests when rendering directly to the display. Should I file this as a separate WebKit bug, or make it part of my patch? Patch: diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp index 311b2c7..60bfd55 100644 --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp @@ -268,6 +268,7 @@ void LayerRendererChromium::drawLayers(const IntRect& visibleRect, const IntRect m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT); updateAndDrawRootLayer(tilePaint, scrollbarPaint, visibleRect, contentRect); + GLC(m_context.get(), m_context->colorMask(true, true, true, true)); // Set the root visible/content rects --- used by subsequent drawLayers calls. m_rootVisibleRect = visibleRect; 327587 45 vangelis 2010-12-29 09:28:49 -0800 We really don't need non-one alpha values in the backbuffer as the composited page is assumed to be opaque. The blending mode we use (ONE, ONE_MINUS_SRC_ALPHA) doesn't use the alpha values stored in the backbuffer either so those values are essentially completely ignored. My suggestion would be to update the reference images generated by DRT rather than enable alpha writes. (In reply to comment #44) > OK, I think I've tracked down the change that is giving my patch difficulties. Before the root-layer tiling patch landed, the code that rendered the root layer use to call > > GLC(m_context.get(), m_context->colorMask(true, true, true, false)); > > before the call to LayerChromium::drawTexturedQuad and call > > GLC(m_context.get(), m_context->colorMask(true, true, true, true)); > > afterwards. > > The root-layer tiling patch masks off the alpha channel (makes the first call), but never turns it back on (the second call). The patch below turns it back on after the call to updateAndDrawRootLayer(), and restores the results of this patch (rendering to offscreen texture) without breaking any tests when rendering directly to the display. > > Should I file this as a separate WebKit bug, or make it part of my patch? > > Patch: > > diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > index 311b2c7..60bfd55 100644 > --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > @@ -268,6 +268,7 @@ void LayerRendererChromium::drawLayers(const IntRect& visibleRect, const IntRect > m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT); > > updateAndDrawRootLayer(tilePaint, scrollbarPaint, visibleRect, contentRect); > + GLC(m_context.get(), m_context->colorMask(true, true, true, true)); > > // Set the root visible/content rects --- used by subsequent drawLayers calls. > m_rootVisibleRect = visibleRect; 327596 46 wjmaclean 2010-12-29 09:45:52 -0800 (In reply to comment #45) > We really don't need non-one alpha values in the backbuffer as the composited page is assumed to be opaque. The blending mode we use (ONE, ONE_MINUS_SRC_ALPHA) doesn't use the alpha values stored in the backbuffer either so those values are essentially completely ignored. > > My suggestion would be to update the reference images generated by DRT rather than enable alpha writes. > Presumably this needs to be done in WebViewImpl::doPixelReadbackToCanvas before the call to ImageBuffer::putPremultipliedImageData to avoid getting asserts about alpha values less than r,g,b component values. ImageBuffer doesn't seem to have a function that resets the alpha values, and the code I used for my experiment is pretty hacky. Is there an elegant way to do this? Would something like glPixelTransferf(GL_ALPHA_BIAS, 1.0f); before calling glReadPixels be OK? 327610 47 vangelis 2010-12-29 10:11:22 -0800 (In reply to comment #46) > (In reply to comment #45) > > We really don't need non-one alpha values in the backbuffer as the composited page is assumed to be opaque. The blending mode we use (ONE, ONE_MINUS_SRC_ALPHA) doesn't use the alpha values stored in the backbuffer either so those values are essentially completely ignored. > > > > My suggestion would be to update the reference images generated by DRT rather than enable alpha writes. > > > > Presumably this needs to be done in WebViewImpl::doPixelReadbackToCanvas before the call to ImageBuffer::putPremultipliedImageData to avoid getting asserts about alpha values less than r,g,b component values. ImageBuffer doesn't seem to have a function that resets the alpha values, and the code I used for my experiment is pretty hacky. Is there an elegant way to do this? > > Would something like > > glPixelTransferf(GL_ALPHA_BIAS, 1.0f); > > before calling glReadPixels be OK? If you clear the backbuffer with a color that has alpha = 1 then disable alpha writes via glColorMask(true, true, true, false) you will get what you need. You need to remember to turn on alpha writes before calling glClear() otherwise the alpha channel won't be cleared. So the sequence in drawLayers() would be something like: m_context->clearColor(0, 0, 1, 1); m_context->colorMask(true, true, true, true); m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT); m_context->colorMask(true, true, true, false); 327630 48 wjmaclean 2010-12-29 11:08:20 -0800 (In reply to comment #47) > > If you clear the backbuffer with a color that has alpha = 1 then disable alpha writes via glColorMask(true, true, true, false) you will get what you need. You need to remember to turn on alpha writes before calling glClear() otherwise the alpha channel won't be cleared. So the sequence in drawLayers() would be something like: > > m_context->clearColor(0, 0, 1, 1); > m_context->colorMask(true, true, true, true); > m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT); > m_context->colorMask(true, true, true, false); I tried this in drawLayers (where the existing clear is), but it failed, giving Skia asserts on "r <= a". I think this means that some subsequent layer is getting drawn with the alpha mask turned on, and it has some alpha values < 1.0 - does that make sense? When rendering offscreen, this only applies to the offscreen RenderSurface. If, on the other hand, I do this sequence on the display buffer (just before copying the pixels from the offscreen RenderSurface) then it works. I would assume we should still leave the alpha-clear code at the top of drawLayers, but that we should also expect to have to do this clear again when drawing the offscreen RenderSurface to the display. Does that sound OK? 327650 49 77636 wjmaclean 2010-12-29 11:55:41 -0800 Created attachment 77636 Patch 327651 50 77636 wjmaclean 2010-12-29 11:56:53 -0800 Comment on attachment 77636 Patch Patch for discussion purposes (do not review yet please). Test code left in showing resetting of alpha values before copying offscreen RenderSurface to display. 327660 51 77636 vangelis 2010-12-29 12:13:51 -0800 Comment on attachment 77636 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=77636&action=review > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:270 > + m_context->colorMask(true, true, true, false); Since you set the color mask here, you should remove the colorMask call from updateAndDrawRootLayer() > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:701 > + GLC(m_context.get(), m_context->colorMask(true, true, true, false)); the color mask should be already (true, true, true, false). You shouldn't be modifying it here. > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:727 > + GLC(m_context.get(), m_context->colorMask(true, true, true, false)); Again, the color mask should be correct. 327662 52 wjmaclean 2010-12-29 12:24:10 -0800 (In reply to comment #51) > (From update of attachment 77636 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=77636&action=review > > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:270 > > + m_context->colorMask(true, true, true, false); > > Since you set the color mask here, you should remove the colorMask call from updateAndDrawRootLayer() > > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:701 > > + GLC(m_context.get(), m_context->colorMask(true, true, true, false)); > > the color mask should be already (true, true, true, false). You shouldn't be modifying it here. > > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:727 > > + GLC(m_context.get(), m_context->colorMask(true, true, true, false)); > > Again, the color mask should be correct. Sure thing. The colorMasks on lines 701 and 727 weren't intended to be left in (forgot to take them out) ... I was just trying them to see if I could find where the non-unit alpha values were creeping in ... I'll submit a proper patch once I've re-tested on a mac. 327678 53 77640 wjmaclean 2010-12-29 13:13:10 -0800 Created attachment 77640 Patch 329156 54 77640 kbr 2011-01-04 13:03:02 -0800 Comment on attachment 77640 Patch The revised patch looks okay to me; if Vangelis can give it an LGTM I'll r+ it. 329161 55 77640 vangelis 2011-01-04 13:16:45 -0800 Comment on attachment 77640 Patch Looks good. Thanks! 329301 56 77640 commit-queue 2011-01-04 16:54:05 -0800 Comment on attachment 77640 Patch Clearing flags on attachment: 77640 Committed r75030: <http://trac.webkit.org/changeset/75030> 329302 57 commit-queue 2011-01-04 16:54:12 -0800 All reviewed patches have been landed. Closing bug. 329341 58 webkit.review.bot 2011-01-04 17:50:29 -0800 http://trac.webkit.org/changeset/75030 might have broken Leopard Intel Debug (Tests) 76228 2010-12-10 11:36:41 -0800 2010-12-10 12:05:27 -0800 Patch bug-50833-20101210144004.patch text/plain 11231 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YWQwZjVlM2UwZjlhYTE2ZjRlNDBhZDkyMTFmMmE2ZDYxYzAxYTRiMC4uYjU4NjJlMWJlZGYxMjAx NTMyOGMzMTAzODVkN2Q5MGJmMGZjZDJmNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAxMC0xMi0xMCAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9ydCB0 byBjb21wb3NpdG9yIHRvIGNvbXBvc2l0ZSB0byBvZmZzY3JlZW4gdGV4dHVyZS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwODMzCisKKyAgICAgICAg QSBwYXRjaCB0byBleHRlbmQgY29tcG9zaXRvciB0byBiZSBhYmxlIHRvIGNvbXBvc2l0ZSBpbnRv IGFuIG9mZnNjcmVlbiB0ZXh0dXJlIGluc3RlYWQKKyAgICAgICAgb2YganVzdCBkaXJlY3RseSB0 byB0aGUgZGlzcGxheSBidWZmZXIuIEJ1aWxkcyBvbiBSZW5kZXJTdXJmYWNlQ2hyb21pdW0gc3Vw cG9ydC4KKworICAgICAgICBFeHRlcm5hbCBiZWhhdmlvdXIgbm90IGNoYW5nZWQsIHNvIG5vIHRl c3RzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6 cHJlcGFyZVRvRHJhd0xheWVycyk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hy b21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9t aXVtOjpzZXRDb21wb3NpdGVPZmZzY3JlZW4pOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5k ZXJlckNocm9taXVtOjpjb3B5T2Zmc2NyZWVuVGV4dHVyZVRvRGlzcGxheSk6CisgICAgICAgIChX ZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OnVzZVJlbmRlclN1cmZhY2UpOgorICAgICAg ICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpzZXRTY2lzc29yVG9SZWN0KToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0u aDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6aXNDb21wb3NpdGlu Z09mZnNjcmVlbik6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06Omdl dE9mZnNjcmVlblRleHR1cmVJRCk6CisKIDIwMTAtMTItMDkgIFl1cnkgU2VtaWtoYXRza3kgIDx5 dXJ5c0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgUGF2ZWwgRmVsZG1hbi4K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5k ZXJlckNocm9taXVtLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5 ZXJSZW5kZXJlckNocm9taXVtLmNwcAppbmRleCAxYmRlYTg1MDAyNTZmZTAyNzk5Y2Y1YjIzNjVi ODQzYzBkMzdhNTMwLi4wZmM3NmQwNTAwOGIwMTYwZGQ1ZjkwZWM5Y2Y0NjhhYjhkMzNkMTFjIDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVy ZXJDaHJvbWl1bS5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCkBAIC0xOTgsNiArMTk4LDggQEAgdm9pZCBMYXllclJl bmRlcmVyQ2hyb21pdW06OnByZXBhcmVUb0RyYXdMYXllcnMoY29uc3QgSW50UmVjdCYgdmlzaWJs ZVJlY3QsIGNvbnMKIAogICAgICAgICBHTEMobV9jb250ZXh0LCBtX2NvbnRleHQtPnRleEltYWdl MkQoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQsIDAsIEdyYXBoaWNzQ29udGV4dDNEOjpS R0JBLCBtX3Jvb3RMYXllclRleHR1cmVXaWR0aCwgbV9yb290TGF5ZXJUZXh0dXJlSGVpZ2h0LCAw LCBHcmFwaGljc0NvbnRleHQzRDo6UkdCQSwgR3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZ VEUsIDApKTsKIAorICAgICAgICBpZiAobV9yb290TGF5ZXItPm1fcmVuZGVyU3VyZmFjZS5nZXQo KSkKKyAgICAgICAgICAgIG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UtPm1fY29udGVudFJl Y3QgPSBJbnRSZWN0KDAsIDAsIG1fcm9vdExheWVyVGV4dHVyZVdpZHRoLCBtX3Jvb3RMYXllclRl eHR1cmVIZWlnaHQpOwogICAgICAgICAvLyBSZXNldCB0aGUgY3VycmVudCByZW5kZXIgc3VyZmFj ZSB0byBmb3JjZSBhbiB1cGRhdGUgb2YgdGhlIHZpZXdwb3J0IGFuZAogICAgICAgICAvLyBwcm9q ZWN0aW9uIG1hdHJpeCBuZXh0IHRpbWUgdXNlUmVuZGVyU3VyZmFjZSBpcyBjYWxsZWQuCiAgICAg ICAgIG1fY3VycmVudFJlbmRlclN1cmZhY2UgPSAwOwpAQCAtMjg5LDEwICsyOTEsMTIgQEAgdm9p ZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMoY29uc3QgSW50UmVjdCYgdmlzaWJs ZVJlY3QsIGNvbnN0IEludFJlY3QKIHsKICAgICBBU1NFUlQobV9oYXJkd2FyZUNvbXBvc2l0aW5n KTsKIAorICAgIGlmICghbV9yb290TGF5ZXItPm1fcmVuZGVyU3VyZmFjZS5nZXQoKSkKKyAgICAg ICAgbV9yb290TGF5ZXItPmNyZWF0ZVJlbmRlclN1cmZhY2UoKTsKKworICAgIG1fcm9vdExheWVy LT5tX3JlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QgPSBJbnRSZWN0KDAsIDAsIG1fcm9vdExh eWVyVGV4dHVyZVdpZHRoLCBtX3Jvb3RMYXllclRleHR1cmVIZWlnaHQpOworCiAgICAgbV9kZWZh dWx0UmVuZGVyU3VyZmFjZSA9IG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UuZ2V0KCk7Ci0g ICAgaWYgKCFtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKQotICAgICAgICBtX2RlZmF1bHRSZW5kZXJT dXJmYWNlID0gbV9yb290TGF5ZXItPmNyZWF0ZVJlbmRlclN1cmZhY2UoKTsKLSAgICBtX2RlZmF1 bHRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0ID0gSW50UmVjdCgwLCAwLCBtX3Jvb3RMYXll clRleHR1cmVXaWR0aCwgbV9yb290TGF5ZXJUZXh0dXJlSGVpZ2h0KTsKIAogICAgIHVzZVJlbmRl clN1cmZhY2UobV9kZWZhdWx0UmVuZGVyU3VyZmFjZSk7CiAKQEAgLTMyMCwxMiArMzI0LDE0IEBA IHZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKGNvbnN0IEludFJlY3QmIHZp c2libGVSZWN0LCBjb25zdCBJbnRSZWN0CiAgICAgLy8gU2V0IHRoZSByb290IHZpc2libGUvY29u dGVudCByZWN0cyAtLS0gdXNlZCBieSBzdWJzZXF1ZW50IGRyYXdMYXllcnMgY2FsbHMuCiAgICAg bV9yb290VmlzaWJsZVJlY3QgPSB2aXNpYmxlUmVjdDsKICAgICBtX3Jvb3RDb250ZW50UmVjdCA9 IGNvbnRlbnRSZWN0OworICAgIG1fcm9vdENvbnRlbnRSZWN0LnNldFkoMTUpOwogCiAgICAgLy8g U2Npc3NvciBvdXQgdGhlIHNjcm9sbGJhcnMgdG8gYXZvaWQgcmVuZGVyaW5nIG9uIHRvcCBvZiB0 aGVtLgogICAgIEludFJlY3Qgcm9vdFNjaXNzb3JSZWN0KGNvbnRlbnRSZWN0KTsKICAgICAvLyBU aGUgc2Npc3NvclJlY3Qgc2hvdWxkIG5vdCBpbmNsdWRlIHRoZSBzY3JvbGwgb2Zmc2V0LgogICAg IHJvb3RTY2lzc29yUmVjdC5tb3ZlKC1tX3Njcm9sbFBvc2l0aW9uLngoKSwgLW1fc2Nyb2xsUG9z aXRpb24ueSgpKTsKICAgICBtX3Jvb3RMYXllci0+bV9zY2lzc29yUmVjdCA9IHJvb3RTY2lzc29y UmVjdDsKKyAgICBtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlLT5tX3NjaXNzb3JSZWN0ID0g cm9vdFNjaXNzb3JSZWN0OyAvLyBEbyBJIG5lZWQgdGhpcz8KIAogICAgIFZlY3RvcjxMYXllckNo cm9taXVtKj4gcmVuZGVyU3VyZmFjZUxheWVyTGlzdDsKICAgICByZW5kZXJTdXJmYWNlTGF5ZXJM aXN0LmFwcGVuZChtX3Jvb3RMYXllci5nZXQoKSk7CkBAIC02NTYsNiArNjYyLDUzIEBAIHZvaWQg TGF5ZXJSZW5kZXJlckNocm9taXVtOjp1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5ZXJDaHJvbWl1 bSogbGF5ZXIsIGNvbnN0IFRyCiAgICAgICAgIHN0ZDo6c3RhYmxlX3NvcnQoJmRlc2NlbmRhbnRz LmF0KHRoaXNMYXllckluZGV4KSwgZGVzY2VuZGFudHMuZW5kKCksIGNvbXBhcmVMYXllclopOwog fQogCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6c2V0Q29tcG9zaXRlT2Zmc2NyZWVuKGJv b2wgY29tcG9zaXRlT2Zmc2NyZWVuKQoreworICAgIG1fcmVuZGVyT2Zmc2NyZWVuID0gY29tcG9z aXRlT2Zmc2NyZWVuOworCisgICAgaWYgKCFtX3Jvb3RMYXllci5nZXQoKSkgeworICAgICAgICBt X3JlbmRlck9mZnNjcmVlbiA9IGZhbHNlOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAg aWYgKG1fcmVuZGVyT2Zmc2NyZWVuKSB7CisgICAgICAgIC8vIE5lZWQgdG8gZXhwbGljaXRseSBz ZXQgYSBMYXllclJlbmRlcmVyQ2hyb21pdW0gZm9yIHRoZSBsYXllciB3aXRoIHRoZSBvZmZzY3Jl ZW4gdGV4dHVyZSwKKyAgICAgICAgLy8gb3IgZWxzZSB0aGUgY2FsbCB0byBwcmVwYXJlQ29udGVu dHNUZXh0dXJlKCkgaW4gdXNlUmVuZGVyU3VyZmFjZSgpIHdpbGwgZmFpbC4KKyAgICAgICAgbV9y b290TGF5ZXItPnNldExheWVyUmVuZGVyZXIodGhpcyk7CisgICAgfQorfQorCit2b2lkIExheWVy UmVuZGVyZXJDaHJvbWl1bTo6Y29weU9mZnNjcmVlblRleHR1cmVUb0Rpc3BsYXkoKQoreworICAg IGlmIChtX3JlbmRlck9mZnNjcmVlbikgeworICAgICAgICBtYWtlQ29udGV4dEN1cnJlbnQoKTsK KyAgICAgICAgR0xDKG1fY29udGV4dCwgbV9jb250ZXh0LT5iaW5kVGV4dHVyZShHcmFwaGljc0Nv bnRleHQzRDo6VEVYVFVSRV8yRCwgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZS0+bV9jb250ZW50c1Rl eHR1cmVJZCkpOworICAgICAgICBHTEMobV9jb250ZXh0LCBtX2NvbnRleHQtPmJpbmRGcmFtZWJ1 ZmZlcihHcmFwaGljc0NvbnRleHQzRDo6RlJBTUVCVUZGRVIsIDApKTsKKy8vICAgICAgU2Nyb2xs IGJhcnMgd29uJ3QgcmVuZGVyIGlmIGxpbmUgYmVsb3cgZW5hYmxlZCAuLi4KKy8vICAgICAgICBH TEMobV9jb250ZXh0LCBtX2NvbnRleHQtPmVuYWJsZShHcmFwaGljc0NvbnRleHQzRDo6U0NJU1NP Ul9URVNUKSk7CisgICAgICAgIHNldERyYXdWaWV3cG9ydFJlY3QobV9kZWZhdWx0UmVuZGVyU3Vy ZmFjZS0+bV9jb250ZW50UmVjdCwgdHJ1ZSk7CisgICAgICAgIG1fY29udGV4dC0+Y2xlYXJDb2xv cigxLCAwLCAwLCAxKTsgLy8gQ2xlYXIgdG8gcmVkIGZvciBkaWFnbm9zdGljcy4KKyAgICAgICAg bV9jb250ZXh0LT5jbGVhcihHcmFwaGljc0NvbnRleHQzRDo6Q09MT1JfQlVGRkVSX0JJVCk7Cisg ICAgICAgIGNvbnN0IENvbnRlbnRMYXllckNocm9taXVtOjpTaGFyZWRWYWx1ZXMqIGNvbnRlbnRM YXllclZhbHVlcyA9IGNvbnRlbnRMYXllclNoYXJlZFZhbHVlcygpOworICAgICAgICAvLyBXZSB1 c2UgdGhlIGNvbXBvc2l0b3Igc2hhZGVyIGhlcmUgdG8gYXZvaWQgZG91YmxlIHJldmVyc2luZyB0 aGUgcmVkICYgYmx1ZSBjb21wb25lbnRzLgorICAgICAgICB1c2VTaGFkZXIobV90ZXh0dXJlTGF5 ZXJTaGFkZXJQcm9ncmFtKTsKKyAgICAgICAgR0xDKG1fY29udGV4dCwgbV9jb250ZXh0LT51bmlm b3JtMWkoY29udGVudExheWVyVmFsdWVzLT5zaGFkZXJTYW1wbGVyTG9jYXRpb24oKSwgMCkpOwor ICAgICAgICAvLyBNYXNrIG91dCB3cml0ZXMgdG8gYWxwaGEgY2hhbm5lbDogQ2xlYXJUeXBlIHZp YSBTa2lhIHJlc3VsdHMgaW4gaW52YWxpZAorICAgICAgICAvLyB6ZXJvIGFscGhhIHZhbHVlcyBv biB0ZXh0IGdseXBocy4gVGhlIHJvb3QgbGF5ZXIgaXMgYWx3YXlzIG9wYXF1ZS4KKyAgICAgICAg R0xDKG1fY29udGV4dCwgbV9jb250ZXh0LT5jb2xvck1hc2sodHJ1ZSwgdHJ1ZSwgdHJ1ZSwgZmFs c2UpKTsKKyAgICAgICAgVHJhbnNmb3JtYXRpb25NYXRyaXggbGF5ZXJNYXRyaXg7CisgICAgICAg IGxheWVyTWF0cml4LnRyYW5zbGF0ZTNkKDAuNSAqIG1fZGVmYXVsdFJlbmRlclN1cmZhY2UtPm1f Y29udGVudFJlY3Qud2lkdGgoKSwgMC41ICogbV9kZWZhdWx0UmVuZGVyU3VyZmFjZS0+bV9jb250 ZW50UmVjdC5oZWlnaHQoKSwgMCk7CisgICAgICAgIExheWVyQ2hyb21pdW06OmRyYXdUZXh0dXJl ZFF1YWQobV9jb250ZXh0LmdldCgpLCBtX3Byb2plY3Rpb25NYXRyaXgsIGxheWVyTWF0cml4LAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fZGVmYXVsdFJlbmRlclN1 cmZhY2UtPm1fY29udGVudFJlY3Qud2lkdGgoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LmhlaWdo dCgpLCAxLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRlbnRM YXllclZhbHVlcy0+c2hhZGVyTWF0cml4TG9jYXRpb24oKSwgY29udGVudExheWVyVmFsdWVzLT5z aGFkZXJBbHBoYUxvY2F0aW9uKCkpOworICAgICAgICBHTEMobV9jb250ZXh0LCBtX2NvbnRleHQt PmNvbG9yTWFzayh0cnVlLCB0cnVlLCB0cnVlLCB0cnVlKSk7CisvLyAgICAgICAgR0xDKG1fY29u dGV4dCwgbV9jb250ZXh0LT5kaXNhYmxlKEdyYXBoaWNzQ29udGV4dDNEOjpTQ0lTU09SX1RFU1Qp KTsKKyAgICAgICAgbV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9IDA7IC8vIE5lZWQgdG8gZG8gdGhp cywgb3IgZWxzZSBuZXh0IGNhbGwgdG8gdXNlUmVuZGVyU3VyZmFjZSB3aWxsIHN0aWxsIGJlIGJv dW5kIHRvCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBmcmFtZUJ1ZmZl ciAwLCBhbmQgdXBkYXRlcyB3aWxsIGZhaWwuCisgICAgfQorfQorCiBib29sIExheWVyUmVuZGVy ZXJDaHJvbWl1bTo6dXNlUmVuZGVyU3VyZmFjZShSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIHJlbmRl clN1cmZhY2UpCiB7CiAgICAgaWYgKG1fY3VycmVudFJlbmRlclN1cmZhY2UgPT0gcmVuZGVyU3Vy ZmFjZSkKQEAgLTY2Myw3ICs3MTYsNyBAQCBib29sIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6dXNl UmVuZGVyU3VyZmFjZShSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIHJlbmRlclN1cmZhYwogCiAgICAg bV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9IHJlbmRlclN1cmZhY2U7CiAKLSAgICBpZiAocmVuZGVy U3VyZmFjZSA9PSBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKSB7CisgICAgaWYgKHJlbmRlclN1cmZh Y2UgPT0gbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSAmJiAhbV9yZW5kZXJPZmZzY3JlZW4pIHsKICAg ICAgICAgR0xDKG1fY29udGV4dCwgbV9jb250ZXh0LT5iaW5kRnJhbWVidWZmZXIoR3JhcGhpY3ND b250ZXh0M0Q6OkZSQU1FQlVGRkVSLCAwKSk7CiAgICAgICAgIHNldERyYXdWaWV3cG9ydFJlY3Qo cmVuZGVyU3VyZmFjZS0+bV9jb250ZW50UmVjdCwgdHJ1ZSk7CiAgICAgICAgIHJldHVybiB0cnVl OwpAQCAtNzQzLDggKzc5NiwxMiBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6c2V0U2Np c3NvclRvUmVjdChjb25zdCBJbnRSZWN0JiBzY2lzc29yUmVjdCkKICAgICBpbnQgc2Npc3Nvclgg PSBzY2lzc29yUmVjdC54KCkgLSBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0 LngoKTsKICAgICAvLyBXaGVuIHJlbmRlcmluZyB0byB0aGUgZGVmYXVsdCByZW5kZXIgc3VyZmFj ZSB3ZSdyZSByZW5kZXJpbmcgdXBzaWRlIGRvd24gc28gdGhlIHRvcAogICAgIC8vIG9mIHRoZSBH TCBzY2lzc29yIGlzIHRoZSBib3R0b20gb2Ygb3VyIGxheWVyLgorICAgIC8vIEJ1dCwgaWYgcmVu ZGVyaW5nIHRvIG9mZnNjcmVlbiB0ZXh0dXJlLCB3ZSByZXZlcnNlIG91ciBzZW5zZSBvZiAndXBz aWRlIGRvd24nLgogICAgIGludCBzY2lzc29yWTsKLSAgICBpZiAobV9jdXJyZW50UmVuZGVyU3Vy ZmFjZSA9PSBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKQorICAgIGJvb2wgcmVuZGVyaW5nVXBzaWRl RG93biA9IG1fY3VycmVudFJlbmRlclN1cmZhY2UgPT0gbV9kZWZhdWx0UmVuZGVyU3VyZmFjZTsK KyAgICBpZiAobV9yZW5kZXJPZmZzY3JlZW4pCisgICAgICAgIHJlbmRlcmluZ1Vwc2lkZURvd24g PSAhcmVuZGVyaW5nVXBzaWRlRG93bjsKKyAgICBpZiAocmVuZGVyaW5nVXBzaWRlRG93bikKICAg ICAgICAgc2Npc3NvclkgPSBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0Lmhl aWdodCgpIC0gKHNjaXNzb3JSZWN0LmJvdHRvbSgpIC0gbV9jdXJyZW50UmVuZGVyU3VyZmFjZS0+ bV9jb250ZW50UmVjdC55KCkpOwogICAgIGVsc2UKICAgICAgICAgc2Npc3NvclkgPSBzY2lzc29y UmVjdC55KCkgLSBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LnkoKTsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmggYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVu ZGVyZXJDaHJvbWl1bS5oCmluZGV4IDUzMWQ2NTIyMmRlZDM4YjZmOGU1MjVlODViOGZhMDRjNDFi NWFlZDQuLjU2M2VhNTE3MDg1NzY5NTMzZjVlNWNkMDg4YzE1YmM0MjJlNGMzZmUgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9t aXVtLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uaApAQCAtODgsNiArODgsMTEgQEAgcHVibGljOgogCiAgICAgYm9vbCBoYXJk d2FyZUNvbXBvc2l0aW5nKCkgY29uc3QgeyByZXR1cm4gbV9oYXJkd2FyZUNvbXBvc2l0aW5nOyB9 CiAKKyAgICB2b2lkIHNldENvbXBvc2l0ZU9mZnNjcmVlbihib29sKTsKKyAgICBib29sIGlzQ29t cG9zaXRpbmdPZmZzY3JlZW4oKSB7IHJldHVybiBtX3JlbmRlck9mZnNjcmVlbjsgfQorICAgIHVu c2lnbmVkIGdldE9mZnNjcmVlblRleHR1cmVJRCgpIHsgcmV0dXJuIG1fcmVuZGVyT2Zmc2NyZWVu ID8gbV9yb290TGF5ZXItPm1fcmVuZGVyU3VyZmFjZS0+bV9jb250ZW50c1RleHR1cmVJZCA6IDA7 IH0KKyAgICB2b2lkIGNvcHlPZmZzY3JlZW5UZXh0dXJlVG9EaXNwbGF5KCk7CisKICAgICB2b2lk IHNldFJvb3RMYXllckNhbnZhc1NpemUoY29uc3QgSW50U2l6ZSYpOwogCiAgICAgR3JhcGhpY3ND b250ZXh0KiByb290TGF5ZXJHcmFwaGljc0NvbnRleHQoKSBjb25zdCB7IHJldHVybiBtX3Jvb3RM YXllckdyYXBoaWNzQ29udGV4dC5nZXQoKTsgfQpAQCAtMTU4LDYgKzE2Myw3IEBAIHByaXZhdGU6 CiAgICAgUmVuZGVyU3VyZmFjZUNocm9taXVtKiBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlOwogCiAg ICAgdW5zaWduZWQgbV9vZmZzY3JlZW5GcmFtZWJ1ZmZlcklkOworICAgIGJvb2wgbV9yZW5kZXJP ZmZzY3JlZW47CiAKICNpZiBQTEFURk9STShTS0lBKQogICAgIE93blB0cjxza2lhOjpQbGF0Zm9y bUNhbnZhcz4gbV9yb290TGF5ZXJDYW52YXM7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCAwMzMyMGJmZTY2ZjI5 NmI5ZTUzOThlZWRhMjE3MmJlNmFmMGJkZjVjLi44YmFmZjZiN2YyMDkxNjU2OWY5Nzk4MjQwOTA3 ODBhNmZhOWIzN2U1IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBi L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMC0xMi0xMCAg Vy4gSmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9y dCB0byBjb21wb3NpdG9yIHRvIGNvbXBvc2l0ZSB0byBvZmZzY3JlZW4gdGV4dHVyZS4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwODMzCisKKyAgICAg ICAgRGVtb25zdHJhdGVzIGhvdyBjaGFuZ2VzIHRvIGNvbXBvc2l0b3IgbWlnaHQgYmUgdXNlZCAu Li4gZm9yIGV4YW1wbGUvZGlzY3Vzc2lvbiBvbmx5LgorCisgICAgICAgICogc3JjL1dlYlZpZXdJ bXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6OmRvQ29tcG9zaXRlKToKKwog MjAxMC0xMi0wNyAgQnJpYW4gV2VpbnN0ZWluICA8YndlaW5zdGVpbkBhcHBsZS5jb20+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgSm9obiBTdWxsaXZhbi4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1w bC5jcHAKaW5kZXggN2JlYzI1NDA4ZDc1YzMxMDllYjdmOGY1NmEwZDgyMDBjZmQ4ZTk4YS4uMWIy YjkyYzA4NWFkZmViOTAwOWNiMTYwMjZiOTk1NTI5ZmQ1OTc1ZiAxMDA2NDQKLS0tIGEvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJWaWV3SW1wbC5jcHAKQEAgLTI0ODIsNiArMjQ4Miw3IEBAIHZvaWQgV2ViVmlld0ltcGw6OmRv Q29tcG9zaXRlKCkKICAgICBJbnRSZWN0IHZpZXdQb3J0ID0gSW50UmVjdCgwLCAwLCBtX3NpemUu d2lkdGgsIG1fc2l6ZS5oZWlnaHQpOwogCiAgICAgLy8gR2l2ZSB0aGUgY29tcG9zaXRvciBhIGNo YW5jZSB0byBzZXR1cC9yZXNpemUgdGhlIHJvb3QgdGV4dHVyZSBoYW5kbGUgYW5kIHBlcmZvcm0g c2Nyb2xsaW5nLgorICAgIG1fbGF5ZXJSZW5kZXJlci0+c2V0Q29tcG9zaXRlT2Zmc2NyZWVuKHRy dWUpOyAvLyBNdXN0IGFsc28gd29yayBjb3JyZWN0bHkgaWYgc2V0ICdmYWxzZScKICAgICBtX2xh eWVyUmVuZGVyZXItPnByZXBhcmVUb0RyYXdMYXllcnModmlzaWJsZVJlY3QsIGNvbnRlbnRSZWN0 LCBJbnRQb2ludCh2aWV3LT5zY3JvbGxYKCksIHZpZXctPnNjcm9sbFkoKSkpOwogCiAgICAgLy8g RHJhdyB0aGUgY29udGVudHMgb2YgdGhlIHJvb3QgbGF5ZXIuCkBAIC0yNTA1LDYgKzI1MDYsNyBA QCB2b2lkIFdlYlZpZXdJbXBsOjpkb0NvbXBvc2l0ZSgpCiAKICAgICAvLyBEcmF3IHRoZSBhY3R1 YWwgbGF5ZXJzLi4uCiAgICAgbV9sYXllclJlbmRlcmVyLT5kcmF3TGF5ZXJzKHZpc2libGVSZWN0 LCBjb250ZW50UmVjdCk7CisgICAgbV9sYXllclJlbmRlcmVyLT5jb3B5T2Zmc2NyZWVuVGV4dHVy ZVRvRGlzcGxheSgpOwogfQogCiB2b2lkIFdlYlZpZXdJbXBsOjpyZWFsbG9jYXRlUmVuZGVyZXIo KQo= 76232 2010-12-10 12:05:27 -0800 2010-12-14 11:17:30 -0800 Patch, with some extraneous lines removed. wk50833.patch text/plain 10432 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YWQwZjVlMy4uYjU4NjJlMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAxMC0xMi0xMCAgVy4gSmFtZXMgTWFj TGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9ydCB0byBjb21wb3Np dG9yIHRvIGNvbXBvc2l0ZSB0byBvZmZzY3JlZW4gdGV4dHVyZS4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwODMzCisKKyAgICAgICAgQSBwYXRjaCB0 byBleHRlbmQgY29tcG9zaXRvciB0byBiZSBhYmxlIHRvIGNvbXBvc2l0ZSBpbnRvIGFuIG9mZnNj cmVlbiB0ZXh0dXJlIGluc3RlYWQKKyAgICAgICAgb2YganVzdCBkaXJlY3RseSB0byB0aGUgZGlz cGxheSBidWZmZXIuIEJ1aWxkcyBvbiBSZW5kZXJTdXJmYWNlQ2hyb21pdW0gc3VwcG9ydC4KKwor ICAgICAgICBFeHRlcm5hbCBiZWhhdmlvdXIgbm90IGNoYW5nZWQsIHNvIG5vIHRlc3RzLgorCisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVt LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6cHJlcGFyZVRv RHJhd0xheWVycyk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OmRy YXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpzZXRD b21wb3NpdGVPZmZzY3JlZW4pOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9t aXVtOjpjb3B5T2Zmc2NyZWVuVGV4dHVyZVRvRGlzcGxheSk6CisgICAgICAgIChXZWJDb3JlOjpM YXllclJlbmRlcmVyQ2hyb21pdW06OnVzZVJlbmRlclN1cmZhY2UpOgorICAgICAgICAoV2ViQ29y ZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpzZXRTY2lzc29yVG9SZWN0KToKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaDoKKyAgICAg ICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6aXNDb21wb3NpdGluZ09mZnNjcmVl bik6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OmdldE9mZnNjcmVl blRleHR1cmVJRCk6CisKIDIwMTAtMTItMDkgIFl1cnkgU2VtaWtoYXRza3kgIDx5dXJ5c0BjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgUGF2ZWwgRmVsZG1hbi4KZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9t aXVtLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmNwcAppbmRleCAxYmRlYTg1Li5jMzkxYjhiIDEwMDY0NAotLS0gYS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKKysr IGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21p dW0uY3BwCkBAIC0xOTgsNiArMTk4LDggQEAgdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnBy ZXBhcmVUb0RyYXdMYXllcnMoY29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnMKIAogICAg ICAgICBHTEMobV9jb250ZXh0LCBtX2NvbnRleHQtPnRleEltYWdlMkQoR3JhcGhpY3NDb250ZXh0 M0Q6OlRFWFRVUkVfMkQsIDAsIEdyYXBoaWNzQ29udGV4dDNEOjpSR0JBLCBtX3Jvb3RMYXllclRl eHR1cmVXaWR0aCwgbV9yb290TGF5ZXJUZXh0dXJlSGVpZ2h0LCAwLCBHcmFwaGljc0NvbnRleHQz RDo6UkdCQSwgR3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZVEUsIDApKTsKIAorICAgICAg ICBpZiAobV9yb290TGF5ZXItPm1fcmVuZGVyU3VyZmFjZS5nZXQoKSkKKyAgICAgICAgICAgIG1f cm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QgPSBJbnRSZWN0KDAsIDAs IG1fcm9vdExheWVyVGV4dHVyZVdpZHRoLCBtX3Jvb3RMYXllclRleHR1cmVIZWlnaHQpOwogICAg ICAgICAvLyBSZXNldCB0aGUgY3VycmVudCByZW5kZXIgc3VyZmFjZSB0byBmb3JjZSBhbiB1cGRh dGUgb2YgdGhlIHZpZXdwb3J0IGFuZAogICAgICAgICAvLyBwcm9qZWN0aW9uIG1hdHJpeCBuZXh0 IHRpbWUgdXNlUmVuZGVyU3VyZmFjZSBpcyBjYWxsZWQuCiAgICAgICAgIG1fY3VycmVudFJlbmRl clN1cmZhY2UgPSAwOwpAQCAtMjg5LDEwICsyOTEsMTIgQEAgdm9pZCBMYXllclJlbmRlcmVyQ2hy b21pdW06OmRyYXdMYXllcnMoY29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnN0IEludFJl Y3QKIHsKICAgICBBU1NFUlQobV9oYXJkd2FyZUNvbXBvc2l0aW5nKTsKIAorICAgIGlmICghbV9y b290TGF5ZXItPm1fcmVuZGVyU3VyZmFjZS5nZXQoKSkKKyAgICAgICAgbV9yb290TGF5ZXItPmNy ZWF0ZVJlbmRlclN1cmZhY2UoKTsKKworICAgIG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2Ut Pm1fY29udGVudFJlY3QgPSBJbnRSZWN0KDAsIDAsIG1fcm9vdExheWVyVGV4dHVyZVdpZHRoLCBt X3Jvb3RMYXllclRleHR1cmVIZWlnaHQpOworCiAgICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSA9 IG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UuZ2V0KCk7Ci0gICAgaWYgKCFtX2RlZmF1bHRS ZW5kZXJTdXJmYWNlKQotICAgICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlID0gbV9yb290TGF5 ZXItPmNyZWF0ZVJlbmRlclN1cmZhY2UoKTsKLSAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5t X2NvbnRlbnRSZWN0ID0gSW50UmVjdCgwLCAwLCBtX3Jvb3RMYXllclRleHR1cmVXaWR0aCwgbV9y b290TGF5ZXJUZXh0dXJlSGVpZ2h0KTsKIAogICAgIHVzZVJlbmRlclN1cmZhY2UobV9kZWZhdWx0 UmVuZGVyU3VyZmFjZSk7CiAKQEAgLTMyNiw2ICszMzAsNyBAQCB2b2lkIExheWVyUmVuZGVyZXJD aHJvbWl1bTo6ZHJhd0xheWVycyhjb25zdCBJbnRSZWN0JiB2aXNpYmxlUmVjdCwgY29uc3QgSW50 UmVjdAogICAgIC8vIFRoZSBzY2lzc29yUmVjdCBzaG91bGQgbm90IGluY2x1ZGUgdGhlIHNjcm9s bCBvZmZzZXQuCiAgICAgcm9vdFNjaXNzb3JSZWN0Lm1vdmUoLW1fc2Nyb2xsUG9zaXRpb24ueCgp LCAtbV9zY3JvbGxQb3NpdGlvbi55KCkpOwogICAgIG1fcm9vdExheWVyLT5tX3NjaXNzb3JSZWN0 ID0gcm9vdFNjaXNzb3JSZWN0OworICAgIG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UtPm1f c2Npc3NvclJlY3QgPSByb290U2Npc3NvclJlY3Q7IC8vIERvIEkgbmVlZCB0aGlzPwogCiAgICAg VmVjdG9yPExheWVyQ2hyb21pdW0qPiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0OwogICAgIHJlbmRl clN1cmZhY2VMYXllckxpc3QuYXBwZW5kKG1fcm9vdExheWVyLmdldCgpKTsKQEAgLTY1Niw2ICs2 NjEsNTEgQEAgdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnVwZGF0ZUxheWVyc1JlY3Vyc2l2 ZShMYXllckNocm9taXVtKiBsYXllciwgY29uc3QgVHIKICAgICAgICAgc3RkOjpzdGFibGVfc29y dCgmZGVzY2VuZGFudHMuYXQodGhpc0xheWVySW5kZXgpLCBkZXNjZW5kYW50cy5lbmQoKSwgY29t cGFyZUxheWVyWik7CiB9CiAKK3ZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpzZXRDb21wb3Np dGVPZmZzY3JlZW4oYm9vbCBjb21wb3NpdGVPZmZzY3JlZW4pCit7CisgICAgbV9yZW5kZXJPZmZz Y3JlZW4gPSBjb21wb3NpdGVPZmZzY3JlZW47CisKKyAgICBpZiAoIW1fcm9vdExheWVyLmdldCgp KSB7CisgICAgICAgIG1fcmVuZGVyT2Zmc2NyZWVuID0gZmFsc2U7CisgICAgICAgIHJldHVybjsK KyAgICB9CisKKyAgICBpZiAobV9yZW5kZXJPZmZzY3JlZW4pIHsKKyAgICAgICAgLy8gTmVlZCB0 byBleHBsaWNpdGx5IHNldCBhIExheWVyUmVuZGVyZXJDaHJvbWl1bSBmb3IgdGhlIGxheWVyIHdp dGggdGhlIG9mZnNjcmVlbiB0ZXh0dXJlLAorICAgICAgICAvLyBvciBlbHNlIHRoZSBjYWxsIHRv IHByZXBhcmVDb250ZW50c1RleHR1cmUoKSBpbiB1c2VSZW5kZXJTdXJmYWNlKCkgd2lsbCBmYWls LgorICAgICAgICBtX3Jvb3RMYXllci0+c2V0TGF5ZXJSZW5kZXJlcih0aGlzKTsKKyAgICB9Cit9 CisKK3ZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpjb3B5T2Zmc2NyZWVuVGV4dHVyZVRvRGlz cGxheSgpCit7CisgICAgaWYgKG1fcmVuZGVyT2Zmc2NyZWVuKSB7CisgICAgICAgIG1ha2VDb250 ZXh0Q3VycmVudCgpOworICAgICAgICBHTEMobV9jb250ZXh0LCBtX2NvbnRleHQtPmJpbmRUZXh0 dXJlKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBtX2RlZmF1bHRSZW5kZXJTdXJmYWNl LT5tX2NvbnRlbnRzVGV4dHVyZUlkKSk7CisgICAgICAgIEdMQyhtX2NvbnRleHQsIG1fY29udGV4 dC0+YmluZEZyYW1lYnVmZmVyKEdyYXBoaWNzQ29udGV4dDNEOjpGUkFNRUJVRkZFUiwgMCkpOwor Ly8gICAgICBTY3JvbGwgYmFycyB3b24ndCByZW5kZXIgaWYgbGluZSBiZWxvdyBlbmFibGVkIC4u LgorICAgICAgICBzZXREcmF3Vmlld3BvcnRSZWN0KG1fZGVmYXVsdFJlbmRlclN1cmZhY2UtPm1f Y29udGVudFJlY3QsIHRydWUpOworICAgICAgICBtX2NvbnRleHQtPmNsZWFyQ29sb3IoMSwgMCwg MCwgMSk7IC8vIENsZWFyIHRvIHJlZCBmb3IgZGlhZ25vc3RpY3MuCisgICAgICAgIG1fY29udGV4 dC0+Y2xlYXIoR3JhcGhpY3NDb250ZXh0M0Q6OkNPTE9SX0JVRkZFUl9CSVQpOworICAgICAgICBj b25zdCBDb250ZW50TGF5ZXJDaHJvbWl1bTo6U2hhcmVkVmFsdWVzKiBjb250ZW50TGF5ZXJWYWx1 ZXMgPSBjb250ZW50TGF5ZXJTaGFyZWRWYWx1ZXMoKTsKKyAgICAgICAgLy8gV2UgdXNlIHRoZSBj b21wb3NpdG9yIHNoYWRlciBoZXJlIHRvIGF2b2lkIGRvdWJsZSByZXZlcnNpbmcgdGhlIHJlZCAm IGJsdWUgY29tcG9uZW50cy4KKyAgICAgICAgdXNlU2hhZGVyKG1fdGV4dHVyZUxheWVyU2hhZGVy UHJvZ3JhbSk7CisgICAgICAgIEdMQyhtX2NvbnRleHQsIG1fY29udGV4dC0+dW5pZm9ybTFpKGNv bnRlbnRMYXllclZhbHVlcy0+c2hhZGVyU2FtcGxlckxvY2F0aW9uKCksIDApKTsKKyAgICAgICAg Ly8gTWFzayBvdXQgd3JpdGVzIHRvIGFscGhhIGNoYW5uZWw6IENsZWFyVHlwZSB2aWEgU2tpYSBy ZXN1bHRzIGluIGludmFsaWQKKyAgICAgICAgLy8gemVybyBhbHBoYSB2YWx1ZXMgb24gdGV4dCBn bHlwaHMuIFRoZSByb290IGxheWVyIGlzIGFsd2F5cyBvcGFxdWUuCisgICAgICAgIEdMQyhtX2Nv bnRleHQsIG1fY29udGV4dC0+Y29sb3JNYXNrKHRydWUsIHRydWUsIHRydWUsIGZhbHNlKSk7Cisg ICAgICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4IGxheWVyTWF0cml4OworICAgICAgICBsYXllck1h dHJpeC50cmFuc2xhdGUzZCgwLjUgKiBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRS ZWN0LndpZHRoKCksIDAuNSAqIG1fZGVmYXVsdFJlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3Qu aGVpZ2h0KCksIDApOworICAgICAgICBMYXllckNocm9taXVtOjpkcmF3VGV4dHVyZWRRdWFkKG1f Y29udGV4dC5nZXQoKSwgbV9wcm9qZWN0aW9uTWF0cml4LCBsYXllck1hdHJpeCwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5t X2NvbnRlbnRSZWN0LndpZHRoKCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZS0+bV9jb250ZW50UmVjdC5oZWlnaHQoKSwgMSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb250ZW50TGF5ZXJWYWx1 ZXMtPnNoYWRlck1hdHJpeExvY2F0aW9uKCksIGNvbnRlbnRMYXllclZhbHVlcy0+c2hhZGVyQWxw aGFMb2NhdGlvbigpKTsKKyAgICAgICAgR0xDKG1fY29udGV4dCwgbV9jb250ZXh0LT5jb2xvck1h c2sodHJ1ZSwgdHJ1ZSwgdHJ1ZSwgdHJ1ZSkpOworICAgICAgICBtX2N1cnJlbnRSZW5kZXJTdXJm YWNlID0gMDsgLy8gTmVlZCB0byBkbyB0aGlzLCBvciBlbHNlIG5leHQgY2FsbCB0byB1c2VSZW5k ZXJTdXJmYWNlIHdpbGwgc3RpbGwgYmUgYm91bmQgdG8KKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIC8vIGZyYW1lQnVmZmVyIDAsIGFuZCB1cGRhdGVzIHdpbGwgZmFpbC4KKyAg ICB9Cit9CisKIGJvb2wgTGF5ZXJSZW5kZXJlckNocm9taXVtOjp1c2VSZW5kZXJTdXJmYWNlKFJl bmRlclN1cmZhY2VDaHJvbWl1bSogcmVuZGVyU3VyZmFjZSkKIHsKICAgICBpZiAobV9jdXJyZW50 UmVuZGVyU3VyZmFjZSA9PSByZW5kZXJTdXJmYWNlKQpAQCAtNjYzLDcgKzcxMyw3IEBAIGJvb2wg TGF5ZXJSZW5kZXJlckNocm9taXVtOjp1c2VSZW5kZXJTdXJmYWNlKFJlbmRlclN1cmZhY2VDaHJv bWl1bSogcmVuZGVyU3VyZmFjCiAKICAgICBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlID0gcmVuZGVy U3VyZmFjZTsKIAotICAgIGlmIChyZW5kZXJTdXJmYWNlID09IG1fZGVmYXVsdFJlbmRlclN1cmZh Y2UpIHsKKyAgICBpZiAocmVuZGVyU3VyZmFjZSA9PSBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlICYm ICFtX3JlbmRlck9mZnNjcmVlbikgewogICAgICAgICBHTEMobV9jb250ZXh0LCBtX2NvbnRleHQt PmJpbmRGcmFtZWJ1ZmZlcihHcmFwaGljc0NvbnRleHQzRDo6RlJBTUVCVUZGRVIsIDApKTsKICAg ICAgICAgc2V0RHJhd1ZpZXdwb3J0UmVjdChyZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LCB0 cnVlKTsKICAgICAgICAgcmV0dXJuIHRydWU7CkBAIC03NDMsOCArNzkzLDEyIEBAIHZvaWQgTGF5 ZXJSZW5kZXJlckNocm9taXVtOjpzZXRTY2lzc29yVG9SZWN0KGNvbnN0IEludFJlY3QmIHNjaXNz b3JSZWN0KQogICAgIGludCBzY2lzc29yWCA9IHNjaXNzb3JSZWN0LngoKSAtIG1fY3VycmVudFJl bmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QueCgpOwogICAgIC8vIFdoZW4gcmVuZGVyaW5nIHRv IHRoZSBkZWZhdWx0IHJlbmRlciBzdXJmYWNlIHdlJ3JlIHJlbmRlcmluZyB1cHNpZGUgZG93biBz byB0aGUgdG9wCiAgICAgLy8gb2YgdGhlIEdMIHNjaXNzb3IgaXMgdGhlIGJvdHRvbSBvZiBvdXIg bGF5ZXIuCisgICAgLy8gQnV0LCBpZiByZW5kZXJpbmcgdG8gb2Zmc2NyZWVuIHRleHR1cmUsIHdl IHJldmVyc2Ugb3VyIHNlbnNlIG9mICd1cHNpZGUgZG93bicuCiAgICAgaW50IHNjaXNzb3JZOwot ICAgIGlmIChtX2N1cnJlbnRSZW5kZXJTdXJmYWNlID09IG1fZGVmYXVsdFJlbmRlclN1cmZhY2Up CisgICAgYm9vbCByZW5kZXJpbmdVcHNpZGVEb3duID0gbV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9 PSBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlOworICAgIGlmIChtX3JlbmRlck9mZnNjcmVlbikKKyAg ICAgICAgcmVuZGVyaW5nVXBzaWRlRG93biA9ICFyZW5kZXJpbmdVcHNpZGVEb3duOworICAgIGlm IChyZW5kZXJpbmdVcHNpZGVEb3duKQogICAgICAgICBzY2lzc29yWSA9IG1fY3VycmVudFJlbmRl clN1cmZhY2UtPm1fY29udGVudFJlY3QuaGVpZ2h0KCkgLSAoc2Npc3NvclJlY3QuYm90dG9tKCkg LSBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LnkoKSk7CiAgICAgZWxzZQog ICAgICAgICBzY2lzc29yWSA9IHNjaXNzb3JSZWN0LnkoKSAtIG1fY3VycmVudFJlbmRlclN1cmZh Y2UtPm1fY29udGVudFJlY3QueSgpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggNTMxZDY1Mi4u NTYzZWE1MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXllclJlbmRlcmVyQ2hyb21pdW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC04OCw2ICs4OCwxMSBAQCBwdWJsaWM6 CiAKICAgICBib29sIGhhcmR3YXJlQ29tcG9zaXRpbmcoKSBjb25zdCB7IHJldHVybiBtX2hhcmR3 YXJlQ29tcG9zaXRpbmc7IH0KIAorICAgIHZvaWQgc2V0Q29tcG9zaXRlT2Zmc2NyZWVuKGJvb2wp OworICAgIGJvb2wgaXNDb21wb3NpdGluZ09mZnNjcmVlbigpIHsgcmV0dXJuIG1fcmVuZGVyT2Zm c2NyZWVuOyB9CisgICAgdW5zaWduZWQgZ2V0T2Zmc2NyZWVuVGV4dHVyZUlEKCkgeyByZXR1cm4g bV9yZW5kZXJPZmZzY3JlZW4gPyBtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlLT5tX2NvbnRl bnRzVGV4dHVyZUlkIDogMDsgfQorICAgIHZvaWQgY29weU9mZnNjcmVlblRleHR1cmVUb0Rpc3Bs YXkoKTsKKwogICAgIHZvaWQgc2V0Um9vdExheWVyQ2FudmFzU2l6ZShjb25zdCBJbnRTaXplJik7 CiAKICAgICBHcmFwaGljc0NvbnRleHQqIHJvb3RMYXllckdyYXBoaWNzQ29udGV4dCgpIGNvbnN0 IHsgcmV0dXJuIG1fcm9vdExheWVyR3JhcGhpY3NDb250ZXh0LmdldCgpOyB9CkBAIC0xNTgsNiAr MTYzLDcgQEAgcHJpdmF0ZToKICAgICBSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIG1fY3VycmVudFJl bmRlclN1cmZhY2U7CiAKICAgICB1bnNpZ25lZCBtX29mZnNjcmVlbkZyYW1lYnVmZmVySWQ7Cisg ICAgYm9vbCBtX3JlbmRlck9mZnNjcmVlbjsKIAogI2lmIFBMQVRGT1JNKFNLSUEpCiAgICAgT3du UHRyPHNraWE6OlBsYXRmb3JtQ2FudmFzPiBtX3Jvb3RMYXllckNhbnZhczsKZGlmZiAtLWdpdCBh L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmlu ZGV4IDAzMzIwYmYuLjhiYWZmNmIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEw LTEyLTEwICBXLiBKYW1lcyBNYWNMZWFuICA8d2ptYWNsZWFuQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbY2hyb21pdW1dIEFk ZCBzdXBwb3J0IHRvIGNvbXBvc2l0b3IgdG8gY29tcG9zaXRlIHRvIG9mZnNjcmVlbiB0ZXh0dXJl LgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTA4MzMK KworICAgICAgICBEZW1vbnN0cmF0ZXMgaG93IGNoYW5nZXMgdG8gY29tcG9zaXRvciBtaWdodCBi ZSB1c2VkIC4uLiBmb3IgZXhhbXBsZS9kaXNjdXNzaW9uIG9ubHkuCisKKyAgICAgICAgKiBzcmMv V2ViVmlld0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6ZG9Db21wb3Np dGUpOgorCiAyMDEwLTEyLTA3ICBCcmlhbiBXZWluc3RlaW4gIDxid2VpbnN0ZWluQGFwcGxlLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBKb2huIFN1bGxpdmFuLgpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YlZpZXdJbXBsLmNwcAppbmRleCA3YmVjMjU0Li4xYjJiOTJjIDEwMDY0NAotLS0gYS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YlZpZXdJbXBsLmNwcApAQCAtMjQ4Miw2ICsyNDgyLDcgQEAgdm9pZCBXZWJWaWV3SW1wbDo6ZG9D b21wb3NpdGUoKQogICAgIEludFJlY3Qgdmlld1BvcnQgPSBJbnRSZWN0KDAsIDAsIG1fc2l6ZS53 aWR0aCwgbV9zaXplLmhlaWdodCk7CiAKICAgICAvLyBHaXZlIHRoZSBjb21wb3NpdG9yIGEgY2hh bmNlIHRvIHNldHVwL3Jlc2l6ZSB0aGUgcm9vdCB0ZXh0dXJlIGhhbmRsZSBhbmQgcGVyZm9ybSBz Y3JvbGxpbmcuCisgICAgbV9sYXllclJlbmRlcmVyLT5zZXRDb21wb3NpdGVPZmZzY3JlZW4odHJ1 ZSk7IC8vIE11c3QgYWxzbyB3b3JrIGNvcnJlY3RseSBpZiBzZXQgJ2ZhbHNlJwogICAgIG1fbGF5 ZXJSZW5kZXJlci0+cHJlcGFyZVRvRHJhd0xheWVycyh2aXNpYmxlUmVjdCwgY29udGVudFJlY3Qs IEludFBvaW50KHZpZXctPnNjcm9sbFgoKSwgdmlldy0+c2Nyb2xsWSgpKSk7CiAKICAgICAvLyBE cmF3IHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllci4KQEAgLTI1MDUsNiArMjUwNiw3IEBA IHZvaWQgV2ViVmlld0ltcGw6OmRvQ29tcG9zaXRlKCkKIAogICAgIC8vIERyYXcgdGhlIGFjdHVh bCBsYXllcnMuLi4KICAgICBtX2xheWVyUmVuZGVyZXItPmRyYXdMYXllcnModmlzaWJsZVJlY3Qs IGNvbnRlbnRSZWN0KTsKKyAgICBtX2xheWVyUmVuZGVyZXItPmNvcHlPZmZzY3JlZW5UZXh0dXJl VG9EaXNwbGF5KCk7CiB9CiAKIHZvaWQgV2ViVmlld0ltcGw6OnJlYWxsb2NhdGVSZW5kZXJlcigp Cg== 76549 2010-12-14 11:17:34 -0800 2010-12-16 06:54:43 -0800 Patch bug-50833-20101214142118.patch text/plain 9682 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ODEyMTIwNWU4ZWEyNzM1YTc0YWUxYzQzODYyNjZkOTVlNjc0MGZjNi4uMjU3OGIxNjQ3NGMxMzcx NDAwMWRkMTg1YzJmNzQ3NmM4ZTMxZGYyMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAxMC0xMi0xNCAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9ydCB0 byBjb21wb3NpdG9yIHRvIGNvbXBvc2l0ZSB0byBvZmZzY3JlZW4gdGV4dHVyZS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwODMzCisKKyAgICAgICAg QSBwYXRjaCB0byBleHRlbmQgY29tcG9zaXRvciB0byBiZSBhYmxlIHRvIGNvbXBvc2l0ZSBpbnRv IGFuIG9mZnNjcmVlbiB0ZXh0dXJlIGluc3RlYWQKKyAgICAgICAgb2YganVzdCBkaXJlY3RseSB0 byB0aGUgZGlzcGxheSBidWZmZXIuIEJ1aWxkcyBvbiBSZW5kZXJTdXJmYWNlQ2hyb21pdW0gc3Vw cG9ydC4KKworICAgICAgICBFeHRlcm5hbCBiZWhhdmlvdXIgbm90IGNoYW5nZWQsIHNvIG5vIHRl c3RzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6 cHJlcGFyZVRvRHJhd0xheWVycyk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hy b21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9t aXVtOjpzZXRDb21wb3NpdGVPZmZzY3JlZW4pOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5k ZXJlckNocm9taXVtOjpjb3B5T2Zmc2NyZWVuVGV4dHVyZVRvRGlzcGxheSk6CisgICAgICAgIChX ZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OnVzZVJlbmRlclN1cmZhY2UpOgorICAgICAg ICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpzZXRTY2lzc29yVG9SZWN0KToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0u aDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6aXNDb21wb3NpdGlu Z09mZnNjcmVlbik6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06Omdl dE9mZnNjcmVlbkxheWVyVGV4dHVyZSk6CisKIDIwMTAtMTItMTQgIElseWEgVGlraG9ub3Zza3kg IDxsb2lzbG9AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFBhdmVsIEZlbGRt YW4uCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVy UmVuZGVyZXJDaHJvbWl1bS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKaW5kZXggNmQ1ZjY0MmZlNmFmYWU2MDFkMDAwNTc4 ODQzMDdlYzYxNDZmNDAxMy4uMDJlOTRmYTAwYmUzODc3MTNiYWM0YjVmNTgzOWU2ODBjNmE2M2Y5 NSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJl bmRlcmVyQ2hyb21pdW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcApAQCAtMjAyLDYgKzIwMiw5IEBAIHZvaWQgTGF5 ZXJSZW5kZXJlckNocm9taXVtOjpwcmVwYXJlVG9EcmF3TGF5ZXJzKGNvbnN0IEludFJlY3QmIHZp c2libGVSZWN0LCBjb25zCiAKICAgICAgICAgR0xDKG1fY29udGV4dC5nZXQoKSwgbV9jb250ZXh0 LT50ZXhJbWFnZTJEKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCAwLCBHcmFwaGljc0Nv bnRleHQzRDo6UkdCQSwgbV9yb290TGF5ZXJUZXh0dXJlV2lkdGgsIG1fcm9vdExheWVyVGV4dHVy ZUhlaWdodCwgMCwgR3JhcGhpY3NDb250ZXh0M0Q6OlJHQkEsIEdyYXBoaWNzQ29udGV4dDNEOjpV TlNJR05FRF9CWVRFLCAwKSk7CiAKKyAgICAgICAgaWYgKG1fcm9vdExheWVyLT5tX3JlbmRlclN1 cmZhY2UpCisgICAgICAgICAgICBtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlLT5tX2NvbnRl bnRSZWN0ID0gSW50UmVjdCgwLCAwLCBtX3Jvb3RMYXllclRleHR1cmVXaWR0aCwgbV9yb290TGF5 ZXJUZXh0dXJlSGVpZ2h0KTsKKwogICAgICAgICAvLyBSZXNldCB0aGUgY3VycmVudCByZW5kZXIg c3VyZmFjZSB0byBmb3JjZSBhbiB1cGRhdGUgb2YgdGhlIHZpZXdwb3J0IGFuZAogICAgICAgICAv LyBwcm9qZWN0aW9uIG1hdHJpeCBuZXh0IHRpbWUgdXNlUmVuZGVyU3VyZmFjZSBpcyBjYWxsZWQu CiAgICAgICAgIG1fY3VycmVudFJlbmRlclN1cmZhY2UgPSAwOwpAQCAtMjk0LDEwICsyOTcsMTIg QEAgdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMoY29uc3QgSW50UmVjdCYg dmlzaWJsZVJlY3QsIGNvbnN0IEludFJlY3QKIHsKICAgICBBU1NFUlQobV9oYXJkd2FyZUNvbXBv c2l0aW5nKTsKIAorICAgIGlmICghbV9yb290TGF5ZXItPm1fcmVuZGVyU3VyZmFjZSkKKyAgICAg ICAgbV9yb290TGF5ZXItPmNyZWF0ZVJlbmRlclN1cmZhY2UoKTsKKworICAgIG1fcm9vdExheWVy LT5tX3JlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QgPSBJbnRSZWN0KDAsIDAsIG1fcm9vdExh eWVyVGV4dHVyZVdpZHRoLCBtX3Jvb3RMYXllclRleHR1cmVIZWlnaHQpOworCiAgICAgbV9kZWZh dWx0UmVuZGVyU3VyZmFjZSA9IG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UuZ2V0KCk7Ci0g ICAgaWYgKCFtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKQotICAgICAgICBtX2RlZmF1bHRSZW5kZXJT dXJmYWNlID0gbV9yb290TGF5ZXItPmNyZWF0ZVJlbmRlclN1cmZhY2UoKTsKLSAgICBtX2RlZmF1 bHRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0ID0gSW50UmVjdCgwLCAwLCBtX3Jvb3RMYXll clRleHR1cmVXaWR0aCwgbV9yb290TGF5ZXJUZXh0dXJlSGVpZ2h0KTsKIAogICAgIHVzZVJlbmRl clN1cmZhY2UobV9kZWZhdWx0UmVuZGVyU3VyZmFjZSk7CiAKQEAgLTMzMSw2ICszMzYsNyBAQCB2 b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6ZHJhd0xheWVycyhjb25zdCBJbnRSZWN0JiB2aXNp YmxlUmVjdCwgY29uc3QgSW50UmVjdAogICAgIC8vIFRoZSBzY2lzc29yUmVjdCBzaG91bGQgbm90 IGluY2x1ZGUgdGhlIHNjcm9sbCBvZmZzZXQuCiAgICAgcm9vdFNjaXNzb3JSZWN0Lm1vdmUoLW1f c2Nyb2xsUG9zaXRpb24ueCgpLCAtbV9zY3JvbGxQb3NpdGlvbi55KCkpOwogICAgIG1fcm9vdExh eWVyLT5tX3NjaXNzb3JSZWN0ID0gcm9vdFNjaXNzb3JSZWN0OworICAgIG1fcm9vdExheWVyLT5t X3JlbmRlclN1cmZhY2UtPm1fc2Npc3NvclJlY3QgPSByb290U2Npc3NvclJlY3Q7IC8vIERvIEkg bmVlZCB0aGlzPwogCiAgICAgVmVjdG9yPExheWVyQ2hyb21pdW0qPiByZW5kZXJTdXJmYWNlTGF5 ZXJMaXN0OwogICAgIHJlbmRlclN1cmZhY2VMYXllckxpc3QuYXBwZW5kKG1fcm9vdExheWVyLmdl dCgpKTsKQEAgLTY2Miw2ICs2NjgsNDIgQEAgdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnVw ZGF0ZUxheWVyc1JlY3Vyc2l2ZShMYXllckNocm9taXVtKiBsYXllciwgY29uc3QgVHIKICAgICAg ICAgc3RkOjpzdGFibGVfc29ydCgmZGVzY2VuZGFudHMuYXQodGhpc0xheWVySW5kZXgpLCBkZXNj ZW5kYW50cy5lbmQoKSwgY29tcGFyZUxheWVyWik7CiB9CiAKK3ZvaWQgTGF5ZXJSZW5kZXJlckNo cm9taXVtOjpzZXRDb21wb3NpdGVPZmZzY3JlZW4oYm9vbCBjb21wb3NpdGVPZmZzY3JlZW4pCit7 CisgICAgbV9jb21wb3NpdGVPZmZzY3JlZW4gPSBjb21wb3NpdGVPZmZzY3JlZW47CisKKyAgICBp ZiAoIW1fcm9vdExheWVyKSB7CisgICAgICAgIG1fY29tcG9zaXRlT2Zmc2NyZWVuID0gZmFsc2U7 CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBpZiAobV9jb21wb3NpdGVPZmZzY3JlZW4p IHsKKyAgICAgICAgLy8gTmVlZCB0byBleHBsaWNpdGx5IHNldCBhIExheWVyUmVuZGVyZXJDaHJv bWl1bSBmb3IgdGhlIGxheWVyIHdpdGggdGhlIG9mZnNjcmVlbiB0ZXh0dXJlLAorICAgICAgICAv LyBvciBlbHNlIHRoZSBjYWxsIHRvIHByZXBhcmVDb250ZW50c1RleHR1cmUoKSBpbiB1c2VSZW5k ZXJTdXJmYWNlKCkgd2lsbCBmYWlsLgorICAgICAgICBtX3Jvb3RMYXllci0+c2V0TGF5ZXJSZW5k ZXJlcih0aGlzKTsKKyAgICB9Cit9CisKKy8vIFRPRE86IFJlbW92ZSB0aGlzIGZ1bmN0aW9uIC4u LiB0ZXN0IGNvZGUgb25seS4KK3ZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpjb3B5T2Zmc2Ny ZWVuVGV4dHVyZVRvRGlzcGxheSgpCit7CisgICAgaWYgKG1fY29tcG9zaXRlT2Zmc2NyZWVuKSB7 CisgICAgICAgIG1ha2VDb250ZXh0Q3VycmVudCgpOworICAgICAgICBHTEMobV9jb250ZXh0LCBt X2NvbnRleHQtPmJpbmRGcmFtZWJ1ZmZlcihHcmFwaGljc0NvbnRleHQzRDo6RlJBTUVCVUZGRVIs IDApKTsKKyAgICAgICAgc2V0RHJhd1ZpZXdwb3J0UmVjdChtX2RlZmF1bHRSZW5kZXJTdXJmYWNl LT5tX2NvbnRlbnRSZWN0LCB0cnVlKTsKKworICAgICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNl LT5tX2RyYXdUcmFuc2Zvcm0ubWFrZUlkZW50aXR5KCk7CisgICAgICAgIG1fZGVmYXVsdFJlbmRl clN1cmZhY2UtPm1fZHJhd1RyYW5zZm9ybS50cmFuc2xhdGUzZCgwLjUgKiBtX2RlZmF1bHRSZW5k ZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LndpZHRoKCksIDAuNSAqIG1fZGVmYXVsdFJlbmRlclN1 cmZhY2UtPm1fY29udGVudFJlY3QuaGVpZ2h0KCksIDApOworCisgICAgICAgIG1fZGVmYXVsdFJl bmRlclN1cmZhY2UtPm1fZHJhd09wYWNpdHkgPSAxOworCisgICAgICAgIG1fZGVmYXVsdFJlbmRl clN1cmZhY2UtPmRyYXcoKTsKKworICAgICAgICBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlID0gMDsg Ly8gTmVlZCB0byBkbyB0aGlzLCBvciBlbHNlIG5leHQgY2FsbCB0byB1c2VSZW5kZXJTdXJmYWNl IHdpbGwgc3RpbGwgYmUgYm91bmQgdG8KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIC8vIGZyYW1lQnVmZmVyIDAsIGFuZCB1cGRhdGVzIHdpbGwgZmFpbC4KKyAgICB9Cit9CisK IGJvb2wgTGF5ZXJSZW5kZXJlckNocm9taXVtOjp1c2VSZW5kZXJTdXJmYWNlKFJlbmRlclN1cmZh Y2VDaHJvbWl1bSogcmVuZGVyU3VyZmFjZSkKIHsKICAgICBpZiAobV9jdXJyZW50UmVuZGVyU3Vy ZmFjZSA9PSByZW5kZXJTdXJmYWNlKQpAQCAtNjY5LDcgKzcxMSw3IEBAIGJvb2wgTGF5ZXJSZW5k ZXJlckNocm9taXVtOjp1c2VSZW5kZXJTdXJmYWNlKFJlbmRlclN1cmZhY2VDaHJvbWl1bSogcmVu ZGVyU3VyZmFjCiAKICAgICBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlID0gcmVuZGVyU3VyZmFjZTsK IAotICAgIGlmIChyZW5kZXJTdXJmYWNlID09IG1fZGVmYXVsdFJlbmRlclN1cmZhY2UpIHsKKyAg ICBpZiAocmVuZGVyU3VyZmFjZSA9PSBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlICYmICFtX2NvbXBv c2l0ZU9mZnNjcmVlbikgewogICAgICAgICBHTEMobV9jb250ZXh0LmdldCgpLCBtX2NvbnRleHQt PmJpbmRGcmFtZWJ1ZmZlcihHcmFwaGljc0NvbnRleHQzRDo6RlJBTUVCVUZGRVIsIDApKTsKICAg ICAgICAgc2V0RHJhd1ZpZXdwb3J0UmVjdChyZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LCB0 cnVlKTsKICAgICAgICAgcmV0dXJuIHRydWU7CkBAIC03MzcsOCArNzc5LDEyIEBAIHZvaWQgTGF5 ZXJSZW5kZXJlckNocm9taXVtOjpzZXRTY2lzc29yVG9SZWN0KGNvbnN0IEludFJlY3QmIHNjaXNz b3JSZWN0KQogICAgIGludCBzY2lzc29yWCA9IHNjaXNzb3JSZWN0LngoKSAtIG1fY3VycmVudFJl bmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QueCgpOwogICAgIC8vIFdoZW4gcmVuZGVyaW5nIHRv IHRoZSBkZWZhdWx0IHJlbmRlciBzdXJmYWNlIHdlJ3JlIHJlbmRlcmluZyB1cHNpZGUgZG93biBz byB0aGUgdG9wCiAgICAgLy8gb2YgdGhlIEdMIHNjaXNzb3IgaXMgdGhlIGJvdHRvbSBvZiBvdXIg bGF5ZXIuCisgICAgLy8gQnV0LCBpZiByZW5kZXJpbmcgdG8gb2Zmc2NyZWVuIHRleHR1cmUsIHdl IHJldmVyc2Ugb3VyIHNlbnNlIG9mICd1cHNpZGUgZG93bicuCiAgICAgaW50IHNjaXNzb3JZOwot ICAgIGlmIChtX2N1cnJlbnRSZW5kZXJTdXJmYWNlID09IG1fZGVmYXVsdFJlbmRlclN1cmZhY2Up CisgICAgYm9vbCByZW5kZXJpbmdVcHNpZGVEb3duID0gbV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9 PSBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlOworICAgIGlmIChtX2NvbXBvc2l0ZU9mZnNjcmVlbikK KyAgICAgICAgcmVuZGVyaW5nVXBzaWRlRG93biA9ICFyZW5kZXJpbmdVcHNpZGVEb3duOworICAg IGlmIChyZW5kZXJpbmdVcHNpZGVEb3duKQogICAgICAgICBzY2lzc29yWSA9IG1fY3VycmVudFJl bmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QuaGVpZ2h0KCkgLSAoc2Npc3NvclJlY3QuYm90dG9t KCkgLSBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LnkoKSk7CiAgICAgZWxz ZQogICAgICAgICBzY2lzc29yWSA9IHNjaXNzb3JSZWN0LnkoKSAtIG1fY3VycmVudFJlbmRlclN1 cmZhY2UtPm1fY29udGVudFJlY3QueSgpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggYzBlNjEw YTMwZmIxNDRjZTQ4ZTA0YzYzMjBlNDA5OTdjNjI3ZDMzZi4uOGFmNTg5ZjI4NzkxYzVhMDE0OGVk Yzc4NTg2MjE0OTk1NWEwNTNiNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC04OCw2ICs4OCwx MSBAQCBwdWJsaWM6CiAKICAgICBib29sIGhhcmR3YXJlQ29tcG9zaXRpbmcoKSBjb25zdCB7IHJl dHVybiBtX2hhcmR3YXJlQ29tcG9zaXRpbmc7IH0KIAorICAgIHZvaWQgc2V0Q29tcG9zaXRlT2Zm c2NyZWVuKGJvb2wpOworICAgIGJvb2wgaXNDb21wb3NpdGluZ09mZnNjcmVlbigpIHsgcmV0dXJu IG1fY29tcG9zaXRlT2Zmc2NyZWVuOyB9CisgICAgTGF5ZXJUZXh0dXJlKiBnZXRPZmZzY3JlZW5M YXllclRleHR1cmUoKSB7IHJldHVybiBtX2NvbXBvc2l0ZU9mZnNjcmVlbiA/IG1fcm9vdExheWVy LT5tX3JlbmRlclN1cmZhY2UtPm1fY29udGVudHNUZXh0dXJlLmdldCgpIDogMDsgfQorICAgIHZv aWQgY29weU9mZnNjcmVlblRleHR1cmVUb0Rpc3BsYXkoKTsKKwogICAgIHZvaWQgc2V0Um9vdExh eWVyQ2FudmFzU2l6ZShjb25zdCBJbnRTaXplJik7CiAKICAgICBHcmFwaGljc0NvbnRleHQqIHJv b3RMYXllckdyYXBoaWNzQ29udGV4dCgpIGNvbnN0IHsgcmV0dXJuIG1fcm9vdExheWVyR3JhcGhp Y3NDb250ZXh0LmdldCgpOyB9CkBAIC0xNTQsNiArMTU5LDcgQEAgcHJpdmF0ZToKICAgICBSZW5k ZXJTdXJmYWNlQ2hyb21pdW0qIG1fY3VycmVudFJlbmRlclN1cmZhY2U7CiAKICAgICB1bnNpZ25l ZCBtX29mZnNjcmVlbkZyYW1lYnVmZmVySWQ7CisgICAgYm9vbCBtX2NvbXBvc2l0ZU9mZnNjcmVl bjsKIAogI2lmIFBMQVRGT1JNKFNLSUEpCiAgICAgT3duUHRyPHNraWE6OlBsYXRmb3JtQ2FudmFz PiBtX3Jvb3RMYXllckNhbnZhczsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VM b2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDQwMzI1Yzk5OWE0YzVmYzFmMzRm YWEyNDk0ZGViZWM2ZDA1ODFlM2QuLjg1OGVkYzdhMTJkZmNhOWQ4YjgyMTFjMmNmNTMyZmVmYmYy OWU2NTIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0 L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEwLTEyLTE0ICBXLiBKYW1l cyBNYWNMZWFuICA8d2ptYWNsZWFuQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbY2hyb21pdW1dIEFkZCBzdXBwb3J0IHRvIGNv bXBvc2l0b3IgdG8gY29tcG9zaXRlIHRvIG9mZnNjcmVlbiB0ZXh0dXJlLgorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTA4MzMKKworICAgICAgICBEZW1v bnN0cmF0ZXMgaG93IGNoYW5nZXMgdG8gY29tcG9zaXRvciBtaWdodCBiZSB1c2VkIC4uLiBmb3Ig ZXhhbXBsZS9kaXNjdXNzaW9uIG9ubHkuCisKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuY3Bw OgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6ZG9Db21wb3NpdGUpOgorCiAyMDEwLTEy LTEzICBNaWtlIExhd3RoZXIgIDxtaWtlbGF3dGhlckBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgSmFtZXMgUm9iaW5zb24uCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYlZpZXdJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3Bw CmluZGV4IGFjMDVkZDJiNzliMzc5Y2I3M2RjMzYwMDAyODZiNTAwOWZiZTkwMDIuLmUwODg1OGVi NGFjMGUyZGY4YTM0MTNkMTFjM2ZiNTJmYzQ0NzAyMTIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmll d0ltcGwuY3BwCkBAIC0yNDU4LDYgKzI0NTgsNyBAQCB2b2lkIFdlYlZpZXdJbXBsOjpkb0NvbXBv c2l0ZSgpCiAgICAgSW50UmVjdCB2aWV3UG9ydCA9IEludFJlY3QoMCwgMCwgbV9zaXplLndpZHRo LCBtX3NpemUuaGVpZ2h0KTsKIAogICAgIC8vIEdpdmUgdGhlIGNvbXBvc2l0b3IgYSBjaGFuY2Ug dG8gc2V0dXAvcmVzaXplIHRoZSByb290IHRleHR1cmUgaGFuZGxlIGFuZCBwZXJmb3JtIHNjcm9s bGluZy4KKyAgICBtX2xheWVyUmVuZGVyZXItPnNldENvbXBvc2l0ZU9mZnNjcmVlbih0cnVlKTsg Ly8gVE9ETzogcmVtb3ZlIHRoaXMsIHRlc3QgY29kZS4gTXVzdCB3b3JrICd0cnVlJyBvciAnZmFs c2UnLgogICAgIG1fbGF5ZXJSZW5kZXJlci0+cHJlcGFyZVRvRHJhd0xheWVycyh2aXNpYmxlUmVj dCwgY29udGVudFJlY3QsIEludFBvaW50KHZpZXctPnNjcm9sbFgoKSwgdmlldy0+c2Nyb2xsWSgp KSk7CiAKICAgICAvLyBEcmF3IHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllci4KQEAgLTI0 ODEsNiArMjQ4Miw3IEBAIHZvaWQgV2ViVmlld0ltcGw6OmRvQ29tcG9zaXRlKCkKIAogICAgIC8v IERyYXcgdGhlIGFjdHVhbCBsYXllcnMuLi4KICAgICBtX2xheWVyUmVuZGVyZXItPmRyYXdMYXll cnModmlzaWJsZVJlY3QsIGNvbnRlbnRSZWN0KTsKKyAgICBtX2xheWVyUmVuZGVyZXItPmNvcHlP ZmZzY3JlZW5UZXh0dXJlVG9EaXNwbGF5KCk7IC8vIFRPRE86IFJlbW92ZSB0aGlzLCB0ZXN0IGNv ZGUuCiB9CiAKIHZvaWQgV2ViVmlld0ltcGw6OnJlYWxsb2NhdGVSZW5kZXJlcigpCg== 76767 2010-12-16 06:54:47 -0800 2010-12-21 08:00:37 -0800 Patch bug-50833-20101216095841.patch text/plain 6692 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg OWRkNmI0NjNlOWIwNDBlNjUxMGMzZWQ0NTg3NmVjNmFiNzI3ZDdiNC4uMWUzZTQzMjA4NmU2YzA3 Nzg2ZmE0ZTM1MjY3NTFhZWMyNjM2NWUyZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAxMC0xMi0xNiAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9ydCB0 byBjb21wb3NpdG9yIHRvIGNvbXBvc2l0ZSB0byBvZmZzY3JlZW4gdGV4dHVyZS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwODMzCisKKyAgICAgICAg QSBwYXRjaCB0byBleHRlbmQgY29tcG9zaXRvciB0byBiZSBhYmxlIHRvIGNvbXBvc2l0ZSBpbnRv IGFuIG9mZnNjcmVlbiB0ZXh0dXJlIGluc3RlYWQKKyAgICAgICAgb2YganVzdCBkaXJlY3RseSB0 byB0aGUgZGlzcGxheSBidWZmZXIuIEJ1aWxkcyBvbiBSZW5kZXJTdXJmYWNlQ2hyb21pdW0gc3Vw cG9ydC4KKworICAgICAgICBFeHRlcm5hbCBiZWhhdmlvdXIgbm90IGNoYW5nZWQsIHNvIG5vIHRl c3RzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6 TGF5ZXJSZW5kZXJlckNocm9taXVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJD aHJvbWl1bTo6cHJlcGFyZVRvRHJhd0xheWVycyk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJl bmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5k ZXJlckNocm9taXVtOjpzZXRDb21wb3NpdGVPZmZzY3JlZW4pOgorICAgICAgICAoV2ViQ29yZTo6 TGF5ZXJSZW5kZXJlckNocm9taXVtOjp1c2VSZW5kZXJTdXJmYWNlKToKKyAgICAgICAgKFdlYkNv cmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6c2V0U2Npc3NvclRvUmVjdCk6CisgICAgICAgICog cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmg6CisgICAg ICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OmlzQ29tcG9zaXRpbmdPZmZzY3Jl ZW4pOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpnZXRPZmZzY3Jl ZW5MYXllclRleHR1cmUpOgorCiAyMDEwLTEyLTE2ICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVyeXNA Y2hyb21pdW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQuIEZpeCBDaHJvbWl1bSBNYWMgRGVi dWcgQ2xhbmcgY29tcGlsYXRpb24uCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAgYi9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKaW5kZXggNmQ1ZjY0 MmZlNmFmYWU2MDFkMDAwNTc4ODQzMDdlYzYxNDZmNDAxMy4uMzVkNmIxMTVlOTdkZDZjOTA3MGUx MjdkYWJjZjQyZDU2ODQ0ZWMxMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcApAQCAtMTA4LDYg KzEwOCw3IEBAIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6TGF5ZXJSZW5kZXJlckNocm9taXVtKFBh c3NSZWZQdHI8R3JhcGhpY3NDb250ZXh0M0Q+IGNvbnRlCiAgICAgLCBtX2N1cnJlbnRTaGFkZXIo MCkKICAgICAsIG1fY3VycmVudFJlbmRlclN1cmZhY2UoMCkKICAgICAsIG1fb2Zmc2NyZWVuRnJh bWVidWZmZXJJZCgwKQorICAgICwgbV9jb21wb3NpdGVPZmZzY3JlZW4oZmFsc2UpCiAgICAgLCBt X2NvbnRleHQoY29udGV4dCkKICAgICAsIG1fZGVmYXVsdFJlbmRlclN1cmZhY2UoMCkKIHsKQEAg LTIwMiw2ICsyMDMsMTAgQEAgdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnByZXBhcmVUb0Ry YXdMYXllcnMoY29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnMKIAogICAgICAgICBHTEMo bV9jb250ZXh0LmdldCgpLCBtX2NvbnRleHQtPnRleEltYWdlMkQoR3JhcGhpY3NDb250ZXh0M0Q6 OlRFWFRVUkVfMkQsIDAsIEdyYXBoaWNzQ29udGV4dDNEOjpSR0JBLCBtX3Jvb3RMYXllclRleHR1 cmVXaWR0aCwgbV9yb290TGF5ZXJUZXh0dXJlSGVpZ2h0LCAwLCBHcmFwaGljc0NvbnRleHQzRDo6 UkdCQSwgR3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZVEUsIDApKTsKIAorICAgICAgICBp ZiAoIW1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UpCisgICAgICAgICAgICBtX3Jvb3RMYXll ci0+Y3JlYXRlUmVuZGVyU3VyZmFjZSgpOworICAgICAgICBtX3Jvb3RMYXllci0+bV9yZW5kZXJT dXJmYWNlLT5tX2NvbnRlbnRSZWN0ID0gSW50UmVjdCgwLCAwLCBtX3Jvb3RMYXllclRleHR1cmVX aWR0aCwgbV9yb290TGF5ZXJUZXh0dXJlSGVpZ2h0KTsKKwogICAgICAgICAvLyBSZXNldCB0aGUg Y3VycmVudCByZW5kZXIgc3VyZmFjZSB0byBmb3JjZSBhbiB1cGRhdGUgb2YgdGhlIHZpZXdwb3J0 IGFuZAogICAgICAgICAvLyBwcm9qZWN0aW9uIG1hdHJpeCBuZXh0IHRpbWUgdXNlUmVuZGVyU3Vy ZmFjZSBpcyBjYWxsZWQuCiAgICAgICAgIG1fY3VycmVudFJlbmRlclN1cmZhY2UgPSAwOwpAQCAt MjkzLDExICsyOTgsOSBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6dXBkYXRlUm9vdExh eWVyVGV4dHVyZVJlY3QoY29uc3QgSW50UmVjdCYgdXBkYXRlUmVjdAogdm9pZCBMYXllclJlbmRl cmVyQ2hyb21pdW06OmRyYXdMYXllcnMoY29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnN0 IEludFJlY3QmIGNvbnRlbnRSZWN0KQogewogICAgIEFTU0VSVChtX2hhcmR3YXJlQ29tcG9zaXRp bmcpOworICAgIEFTU0VSVChtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlKTsKIAogICAgIG1f ZGVmYXVsdFJlbmRlclN1cmZhY2UgPSBtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlLmdldCgp OwotICAgIGlmICghbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSkKLSAgICAgICAgbV9kZWZhdWx0UmVu ZGVyU3VyZmFjZSA9IG1fcm9vdExheWVyLT5jcmVhdGVSZW5kZXJTdXJmYWNlKCk7Ci0gICAgbV9k ZWZhdWx0UmVuZGVyU3VyZmFjZS0+bV9jb250ZW50UmVjdCA9IEludFJlY3QoMCwgMCwgbV9yb290 TGF5ZXJUZXh0dXJlV2lkdGgsIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCk7CiAKICAgICB1c2VS ZW5kZXJTdXJmYWNlKG1fZGVmYXVsdFJlbmRlclN1cmZhY2UpOwogCkBAIC02NjIsNiArNjY1LDIy IEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjp1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5 ZXJDaHJvbWl1bSogbGF5ZXIsIGNvbnN0IFRyCiAgICAgICAgIHN0ZDo6c3RhYmxlX3NvcnQoJmRl c2NlbmRhbnRzLmF0KHRoaXNMYXllckluZGV4KSwgZGVzY2VuZGFudHMuZW5kKCksIGNvbXBhcmVM YXllclopOwogfQogCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6c2V0Q29tcG9zaXRlT2Zm c2NyZWVuKGJvb2wgY29tcG9zaXRlT2Zmc2NyZWVuKQoreworICAgIG1fY29tcG9zaXRlT2Zmc2Ny ZWVuID0gY29tcG9zaXRlT2Zmc2NyZWVuOworCisgICAgaWYgKCFtX3Jvb3RMYXllcikgeworICAg ICAgICBtX2NvbXBvc2l0ZU9mZnNjcmVlbiA9IGZhbHNlOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgaWYgKG1fY29tcG9zaXRlT2Zmc2NyZWVuKSB7CisgICAgICAgIC8vIE5lZWQgdG8g ZXhwbGljaXRseSBzZXQgYSBMYXllclJlbmRlcmVyQ2hyb21pdW0gZm9yIHRoZSBsYXllciB3aXRo IHRoZSBvZmZzY3JlZW4gdGV4dHVyZSwKKyAgICAgICAgLy8gb3IgZWxzZSB0aGUgY2FsbCB0byBw cmVwYXJlQ29udGVudHNUZXh0dXJlKCkgaW4gdXNlUmVuZGVyU3VyZmFjZSgpIHdpbGwgZmFpbC4K KyAgICAgICAgbV9yb290TGF5ZXItPnNldExheWVyUmVuZGVyZXIodGhpcyk7CisgICAgfQorfQor CiBib29sIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6dXNlUmVuZGVyU3VyZmFjZShSZW5kZXJTdXJm YWNlQ2hyb21pdW0qIHJlbmRlclN1cmZhY2UpCiB7CiAgICAgaWYgKG1fY3VycmVudFJlbmRlclN1 cmZhY2UgPT0gcmVuZGVyU3VyZmFjZSkKQEAgLTY2OSw3ICs2ODgsNyBAQCBib29sIExheWVyUmVu ZGVyZXJDaHJvbWl1bTo6dXNlUmVuZGVyU3VyZmFjZShSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIHJl bmRlclN1cmZhYwogCiAgICAgbV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9IHJlbmRlclN1cmZhY2U7 CiAKLSAgICBpZiAocmVuZGVyU3VyZmFjZSA9PSBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKSB7Cisg ICAgaWYgKHJlbmRlclN1cmZhY2UgPT0gbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSAmJiAhbV9jb21w b3NpdGVPZmZzY3JlZW4pIHsKICAgICAgICAgR0xDKG1fY29udGV4dC5nZXQoKSwgbV9jb250ZXh0 LT5iaW5kRnJhbWVidWZmZXIoR3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSLCAwKSk7CiAg ICAgICAgIHNldERyYXdWaWV3cG9ydFJlY3QocmVuZGVyU3VyZmFjZS0+bV9jb250ZW50UmVjdCwg dHJ1ZSk7CiAgICAgICAgIHJldHVybiB0cnVlOwpAQCAtNzM3LDggKzc1Niw5IEBAIHZvaWQgTGF5 ZXJSZW5kZXJlckNocm9taXVtOjpzZXRTY2lzc29yVG9SZWN0KGNvbnN0IEludFJlY3QmIHNjaXNz b3JSZWN0KQogICAgIGludCBzY2lzc29yWCA9IHNjaXNzb3JSZWN0LngoKSAtIG1fY3VycmVudFJl bmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QueCgpOwogICAgIC8vIFdoZW4gcmVuZGVyaW5nIHRv IHRoZSBkZWZhdWx0IHJlbmRlciBzdXJmYWNlIHdlJ3JlIHJlbmRlcmluZyB1cHNpZGUgZG93biBz byB0aGUgdG9wCiAgICAgLy8gb2YgdGhlIEdMIHNjaXNzb3IgaXMgdGhlIGJvdHRvbSBvZiBvdXIg bGF5ZXIuCisgICAgLy8gQnV0LCBpZiByZW5kZXJpbmcgdG8gb2Zmc2NyZWVuIHRleHR1cmUsIHdl IHJldmVyc2Ugb3VyIHNlbnNlIG9mICd1cHNpZGUgZG93bicuCiAgICAgaW50IHNjaXNzb3JZOwot ICAgIGlmIChtX2N1cnJlbnRSZW5kZXJTdXJmYWNlID09IG1fZGVmYXVsdFJlbmRlclN1cmZhY2Up CisgICAgaWYgKG1fY3VycmVudFJlbmRlclN1cmZhY2UgPT0gbV9kZWZhdWx0UmVuZGVyU3VyZmFj ZSAmJiAhbV9jb21wb3NpdGVPZmZzY3JlZW4pCiAgICAgICAgIHNjaXNzb3JZID0gbV9jdXJyZW50 UmVuZGVyU3VyZmFjZS0+bV9jb250ZW50UmVjdC5oZWlnaHQoKSAtIChzY2lzc29yUmVjdC5ib3R0 b20oKSAtIG1fY3VycmVudFJlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QueSgpKTsKICAgICBl bHNlCiAgICAgICAgIHNjaXNzb3JZID0gc2Npc3NvclJlY3QueSgpIC0gbV9jdXJyZW50UmVuZGVy U3VyZmFjZS0+bV9jb250ZW50UmVjdC55KCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oIGIvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAppbmRleCBjMGU2 MTBhMzBmYjE0NGNlNDhlMDRjNjMyMGU0MDk5N2M2MjdkMzNmLi44YWY1ODlmMjg3OTFjNWEwMTQ4 ZWRjNzg1ODYyMTQ5OTU1YTA1M2I0IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCisrKyBiL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKQEAgLTg4LDYgKzg4 LDExIEBAIHB1YmxpYzoKIAogICAgIGJvb2wgaGFyZHdhcmVDb21wb3NpdGluZygpIGNvbnN0IHsg cmV0dXJuIG1faGFyZHdhcmVDb21wb3NpdGluZzsgfQogCisgICAgdm9pZCBzZXRDb21wb3NpdGVP ZmZzY3JlZW4oYm9vbCk7CisgICAgYm9vbCBpc0NvbXBvc2l0aW5nT2Zmc2NyZWVuKCkgeyByZXR1 cm4gbV9jb21wb3NpdGVPZmZzY3JlZW47IH0KKyAgICBMYXllclRleHR1cmUqIGdldE9mZnNjcmVl bkxheWVyVGV4dHVyZSgpIHsgcmV0dXJuIG1fY29tcG9zaXRlT2Zmc2NyZWVuID8gbV9yb290TGF5 ZXItPm1fcmVuZGVyU3VyZmFjZS0+bV9jb250ZW50c1RleHR1cmUuZ2V0KCkgOiAwOyB9CisgICAg dm9pZCBjb3B5T2Zmc2NyZWVuVGV4dHVyZVRvRGlzcGxheSgpOworCiAgICAgdm9pZCBzZXRSb290 TGF5ZXJDYW52YXNTaXplKGNvbnN0IEludFNpemUmKTsKIAogICAgIEdyYXBoaWNzQ29udGV4dCog cm9vdExheWVyR3JhcGhpY3NDb250ZXh0KCkgY29uc3QgeyByZXR1cm4gbV9yb290TGF5ZXJHcmFw aGljc0NvbnRleHQuZ2V0KCk7IH0KQEAgLTE1NCw2ICsxNTksNyBAQCBwcml2YXRlOgogICAgIFJl bmRlclN1cmZhY2VDaHJvbWl1bSogbV9jdXJyZW50UmVuZGVyU3VyZmFjZTsKIAogICAgIHVuc2ln bmVkIG1fb2Zmc2NyZWVuRnJhbWVidWZmZXJJZDsKKyAgICBib29sIG1fY29tcG9zaXRlT2Zmc2Ny ZWVuOwogCiAjaWYgUExBVEZPUk0oU0tJQSkKICAgICBPd25QdHI8c2tpYTo6UGxhdGZvcm1DYW52 YXM+IG1fcm9vdExheWVyQ2FudmFzOwo= 77114 2010-12-21 08:00:42 -0800 2010-12-22 13:56:36 -0800 Patch bug-50833-20101221110503.patch text/plain 6517 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZGJjMzBiZjc4NTBjYWZlNDdkYTAzMDc1NDhiODBlOGUzZGI5NjZhYy4uMDUyYzUzYmNhMzc2M2Ux MzI5YjA5OGJkYjgwY2NiN2E1YTNjYjViNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAxMC0xMi0yMSAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9ydCB0 byBjb21wb3NpdG9yIHRvIGNvbXBvc2l0ZSB0byBvZmZzY3JlZW4gdGV4dHVyZS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwODMzCisKKyAgICAgICAg QSBwYXRjaCB0byBleHRlbmQgY29tcG9zaXRvciB0byBiZSBhYmxlIHRvIGNvbXBvc2l0ZSBpbnRv IGFuIG9mZnNjcmVlbiB0ZXh0dXJlIGluc3RlYWQKKyAgICAgICAgb2YganVzdCBkaXJlY3RseSB0 byB0aGUgZGlzcGxheSBidWZmZXIuIEJ1aWxkcyBvbiBSZW5kZXJTdXJmYWNlQ2hyb21pdW0gc3Vw cG9ydC4KKworICAgICAgICBFeHRlcm5hbCBiZWhhdmlvdXIgbm90IGNoYW5nZWQsIHNvIG5vIHRl c3RzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6 TGF5ZXJSZW5kZXJlckNocm9taXVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJD aHJvbWl1bTo6cHJlcGFyZVRvRHJhd0xheWVycyk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJl bmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5k ZXJlckNocm9taXVtOjpzZXRDb21wb3NpdGVPZmZzY3JlZW4pOgorICAgICAgICAoV2ViQ29yZTo6 TGF5ZXJSZW5kZXJlckNocm9taXVtOjp1c2VSZW5kZXJTdXJmYWNlKToKKyAgICAgICAgKFdlYkNv cmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6c2V0U2Npc3NvclRvUmVjdCk6CisgICAgICAgICog cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmg6CisgICAg ICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OmlzQ29tcG9zaXRpbmdPZmZzY3Jl ZW4pOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpnZXRPZmZzY3Jl ZW5MYXllclRleHR1cmUpOgorCiAyMDEwLTEyLTIxICBNYWhlc2ggS3Vsa2FybmkgIDxtYWhlc2gu a3Vsa2FybmlAbm9raWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFuZHJlYXMgS2xpbmcu CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVu ZGVyZXJDaHJvbWl1bS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xh eWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKaW5kZXggNmQ1ZjY0MmZlNmFmYWU2MDFkMDAwNTc4ODQz MDdlYzYxNDZmNDAxMy4uOGI0MzJkNzkwMTQwMmY2ZDg3MWUyZGIyYjMwZjA2YzI0OWYwNTQyMyAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v TGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcApAQCAtMTA4LDYgKzEwOCw3IEBAIExheWVyUmVuZGVy ZXJDaHJvbWl1bTo6TGF5ZXJSZW5kZXJlckNocm9taXVtKFBhc3NSZWZQdHI8R3JhcGhpY3NDb250 ZXh0M0Q+IGNvbnRlCiAgICAgLCBtX2N1cnJlbnRTaGFkZXIoMCkKICAgICAsIG1fY3VycmVudFJl bmRlclN1cmZhY2UoMCkKICAgICAsIG1fb2Zmc2NyZWVuRnJhbWVidWZmZXJJZCgwKQorICAgICwg bV9jb21wb3NpdGVPZmZzY3JlZW4oZmFsc2UpCiAgICAgLCBtX2NvbnRleHQoY29udGV4dCkKICAg ICAsIG1fZGVmYXVsdFJlbmRlclN1cmZhY2UoMCkKIHsKQEAgLTE5Niw2ICsxOTcsMTEgQEAgdm9p ZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnByZXBhcmVUb0RyYXdMYXllcnMoY29uc3QgSW50UmVj dCYgdmlzaWJsZVJlY3QsIGNvbnMKICAgICAvLyBhbmQgdmlld3BvcnQuCiAgICAgaW50IHZpc2li bGVSZWN0V2lkdGggPSB2aXNpYmxlUmVjdC53aWR0aCgpOwogICAgIGludCB2aXNpYmxlUmVjdEhl aWdodCA9IHZpc2libGVSZWN0LmhlaWdodCgpOworCisgICAgaWYgKCFtX3Jvb3RMYXllci0+bV9y ZW5kZXJTdXJmYWNlKQorICAgICAgICBtX3Jvb3RMYXllci0+Y3JlYXRlUmVuZGVyU3VyZmFjZSgp OworICAgIG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QgPSBJbnRS ZWN0KDAsIDAsIHZpc2libGVSZWN0V2lkdGgsIHZpc2libGVSZWN0SGVpZ2h0KTsKKwogICAgIGlm ICh2aXNpYmxlUmVjdFdpZHRoICE9IG1fcm9vdExheWVyVGV4dHVyZVdpZHRoIHx8IHZpc2libGVS ZWN0SGVpZ2h0ICE9IG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCkgewogICAgICAgICBtX3Jvb3RM YXllclRleHR1cmVXaWR0aCA9IHZpc2libGVSZWN0V2lkdGg7CiAgICAgICAgIG1fcm9vdExheWVy VGV4dHVyZUhlaWdodCA9IHZpc2libGVSZWN0SGVpZ2h0OwpAQCAtMjkzLDExICsyOTksOSBAQCB2 b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6dXBkYXRlUm9vdExheWVyVGV4dHVyZVJlY3QoY29u c3QgSW50UmVjdCYgdXBkYXRlUmVjdAogdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmRyYXdM YXllcnMoY29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnN0IEludFJlY3QmIGNvbnRlbnRS ZWN0KQogewogICAgIEFTU0VSVChtX2hhcmR3YXJlQ29tcG9zaXRpbmcpOworICAgIEFTU0VSVCht X3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlKTsKIAogICAgIG1fZGVmYXVsdFJlbmRlclN1cmZh Y2UgPSBtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlLmdldCgpOwotICAgIGlmICghbV9kZWZh dWx0UmVuZGVyU3VyZmFjZSkKLSAgICAgICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSA9IG1fcm9v dExheWVyLT5jcmVhdGVSZW5kZXJTdXJmYWNlKCk7Ci0gICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFj ZS0+bV9jb250ZW50UmVjdCA9IEludFJlY3QoMCwgMCwgbV9yb290TGF5ZXJUZXh0dXJlV2lkdGgs IG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCk7CiAKICAgICB1c2VSZW5kZXJTdXJmYWNlKG1fZGVm YXVsdFJlbmRlclN1cmZhY2UpOwogCkBAIC02NjIsNiArNjY2LDIyIEBAIHZvaWQgTGF5ZXJSZW5k ZXJlckNocm9taXVtOjp1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5ZXJDaHJvbWl1bSogbGF5ZXIs IGNvbnN0IFRyCiAgICAgICAgIHN0ZDo6c3RhYmxlX3NvcnQoJmRlc2NlbmRhbnRzLmF0KHRoaXNM YXllckluZGV4KSwgZGVzY2VuZGFudHMuZW5kKCksIGNvbXBhcmVMYXllclopOwogfQogCit2b2lk IExheWVyUmVuZGVyZXJDaHJvbWl1bTo6c2V0Q29tcG9zaXRlT2Zmc2NyZWVuKGJvb2wgY29tcG9z aXRlT2Zmc2NyZWVuKQoreworICAgIG1fY29tcG9zaXRlT2Zmc2NyZWVuID0gY29tcG9zaXRlT2Zm c2NyZWVuOworCisgICAgaWYgKCFtX3Jvb3RMYXllcikgeworICAgICAgICBtX2NvbXBvc2l0ZU9m ZnNjcmVlbiA9IGZhbHNlOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKG1fY29t cG9zaXRlT2Zmc2NyZWVuKSB7CisgICAgICAgIC8vIE5lZWQgdG8gZXhwbGljaXRseSBzZXQgYSBM YXllclJlbmRlcmVyQ2hyb21pdW0gZm9yIHRoZSBsYXllciB3aXRoIHRoZSBvZmZzY3JlZW4gdGV4 dHVyZSwKKyAgICAgICAgLy8gb3IgZWxzZSB0aGUgY2FsbCB0byBwcmVwYXJlQ29udGVudHNUZXh0 dXJlKCkgaW4gdXNlUmVuZGVyU3VyZmFjZSgpIHdpbGwgZmFpbC4KKyAgICAgICAgbV9yb290TGF5 ZXItPnNldExheWVyUmVuZGVyZXIodGhpcyk7CisgICAgfQorfQorCiBib29sIExheWVyUmVuZGVy ZXJDaHJvbWl1bTo6dXNlUmVuZGVyU3VyZmFjZShSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIHJlbmRl clN1cmZhY2UpCiB7CiAgICAgaWYgKG1fY3VycmVudFJlbmRlclN1cmZhY2UgPT0gcmVuZGVyU3Vy ZmFjZSkKQEAgLTY2OSw3ICs2ODksNyBAQCBib29sIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6dXNl UmVuZGVyU3VyZmFjZShSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIHJlbmRlclN1cmZhYwogCiAgICAg bV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9IHJlbmRlclN1cmZhY2U7CiAKLSAgICBpZiAocmVuZGVy U3VyZmFjZSA9PSBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKSB7CisgICAgaWYgKHJlbmRlclN1cmZh Y2UgPT0gbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSAmJiAhbV9jb21wb3NpdGVPZmZzY3JlZW4pIHsK ICAgICAgICAgR0xDKG1fY29udGV4dC5nZXQoKSwgbV9jb250ZXh0LT5iaW5kRnJhbWVidWZmZXIo R3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSLCAwKSk7CiAgICAgICAgIHNldERyYXdWaWV3 cG9ydFJlY3QocmVuZGVyU3VyZmFjZS0+bV9jb250ZW50UmVjdCwgdHJ1ZSk7CiAgICAgICAgIHJl dHVybiB0cnVlOwpAQCAtNzM3LDggKzc1Nyw5IEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVt OjpzZXRTY2lzc29yVG9SZWN0KGNvbnN0IEludFJlY3QmIHNjaXNzb3JSZWN0KQogICAgIGludCBz Y2lzc29yWCA9IHNjaXNzb3JSZWN0LngoKSAtIG1fY3VycmVudFJlbmRlclN1cmZhY2UtPm1fY29u dGVudFJlY3QueCgpOwogICAgIC8vIFdoZW4gcmVuZGVyaW5nIHRvIHRoZSBkZWZhdWx0IHJlbmRl ciBzdXJmYWNlIHdlJ3JlIHJlbmRlcmluZyB1cHNpZGUgZG93biBzbyB0aGUgdG9wCiAgICAgLy8g b2YgdGhlIEdMIHNjaXNzb3IgaXMgdGhlIGJvdHRvbSBvZiBvdXIgbGF5ZXIuCisgICAgLy8gQnV0 LCBpZiByZW5kZXJpbmcgdG8gb2Zmc2NyZWVuIHRleHR1cmUsIHdlIHJldmVyc2Ugb3VyIHNlbnNl IG9mICd1cHNpZGUgZG93bicuCiAgICAgaW50IHNjaXNzb3JZOwotICAgIGlmIChtX2N1cnJlbnRS ZW5kZXJTdXJmYWNlID09IG1fZGVmYXVsdFJlbmRlclN1cmZhY2UpCisgICAgaWYgKG1fY3VycmVu dFJlbmRlclN1cmZhY2UgPT0gbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSAmJiAhbV9jb21wb3NpdGVP ZmZzY3JlZW4pCiAgICAgICAgIHNjaXNzb3JZID0gbV9jdXJyZW50UmVuZGVyU3VyZmFjZS0+bV9j b250ZW50UmVjdC5oZWlnaHQoKSAtIChzY2lzc29yUmVjdC5ib3R0b20oKSAtIG1fY3VycmVudFJl bmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QueSgpKTsKICAgICBlbHNlCiAgICAgICAgIHNjaXNz b3JZID0gc2Npc3NvclJlY3QueSgpIC0gbV9jdXJyZW50UmVuZGVyU3VyZmFjZS0+bV9jb250ZW50 UmVjdC55KCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAppbmRleCBjMGU2MTBhMzBmYjE0NGNlNDhlMDRj NjMyMGU0MDk5N2M2MjdkMzNmLi44NzY2YWMxZjRmYzYwMDM1MDkyOWJlMWY1MTI3ZDJhOTA4MTE0 ZjA2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVy UmVuZGVyZXJDaHJvbWl1bS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKQEAgLTg4LDYgKzg4LDEwIEBAIHB1YmxpYzoKIAog ICAgIGJvb2wgaGFyZHdhcmVDb21wb3NpdGluZygpIGNvbnN0IHsgcmV0dXJuIG1faGFyZHdhcmVD b21wb3NpdGluZzsgfQogCisgICAgdm9pZCBzZXRDb21wb3NpdGVPZmZzY3JlZW4oYm9vbCk7Cisg ICAgYm9vbCBpc0NvbXBvc2l0aW5nT2Zmc2NyZWVuKCkgeyByZXR1cm4gbV9jb21wb3NpdGVPZmZz Y3JlZW47IH0KKyAgICBMYXllclRleHR1cmUqIGdldE9mZnNjcmVlbkxheWVyVGV4dHVyZSgpIHsg cmV0dXJuIG1fY29tcG9zaXRlT2Zmc2NyZWVuID8gbV9yb290TGF5ZXItPm1fcmVuZGVyU3VyZmFj ZS0+bV9jb250ZW50c1RleHR1cmUuZ2V0KCkgOiAwOyB9CisKICAgICB2b2lkIHNldFJvb3RMYXll ckNhbnZhc1NpemUoY29uc3QgSW50U2l6ZSYpOwogCiAgICAgR3JhcGhpY3NDb250ZXh0KiByb290 TGF5ZXJHcmFwaGljc0NvbnRleHQoKSBjb25zdCB7IHJldHVybiBtX3Jvb3RMYXllckdyYXBoaWNz Q29udGV4dC5nZXQoKTsgfQpAQCAtMTU0LDYgKzE1OCw3IEBAIHByaXZhdGU6CiAgICAgUmVuZGVy U3VyZmFjZUNocm9taXVtKiBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlOwogCiAgICAgdW5zaWduZWQg bV9vZmZzY3JlZW5GcmFtZWJ1ZmZlcklkOworICAgIGJvb2wgbV9jb21wb3NpdGVPZmZzY3JlZW47 CiAKICNpZiBQTEFURk9STShTS0lBKQogICAgIE93blB0cjxza2lhOjpQbGF0Zm9ybUNhbnZhcz4g bV9yb290TGF5ZXJDYW52YXM7Cg== 77257 2010-12-22 13:56:41 -0800 2010-12-23 13:56:32 -0800 Patch bug-50833-20101222170108.patch text/plain 6770 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZGJhNTQ0MTBmZjhmZGEyNzQxNDhhOGY3ZmZhNTA3NWY2YzkyOWY0NC4uZjhkZGY4NDAwZDFkODJk ZWY5NDNlOTU1ZmM3OWZiZWYwNTAwOWQyZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAxMC0xMi0yMiAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9ydCB0 byBjb21wb3NpdG9yIHRvIGNvbXBvc2l0ZSB0byBvZmZzY3JlZW4gdGV4dHVyZS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwODMzCisKKyAgICAgICAg QSBwYXRjaCB0byBleHRlbmQgY29tcG9zaXRvciB0byBiZSBhYmxlIHRvIGNvbXBvc2l0ZSBpbnRv IGFuIG9mZnNjcmVlbiB0ZXh0dXJlIGluc3RlYWQKKyAgICAgICAgb2YganVzdCBkaXJlY3RseSB0 byB0aGUgZGlzcGxheSBidWZmZXIuIEJ1aWxkcyBvbiBSZW5kZXJTdXJmYWNlQ2hyb21pdW0gc3Vw cG9ydC4KKworICAgICAgICBFeHRlcm5hbCBiZWhhdmlvdXIgbm90IGNoYW5nZWQsIHNvIG5vIHRl c3RzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6 TGF5ZXJSZW5kZXJlckNocm9taXVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJD aHJvbWl1bTo6cHJlcGFyZVRvRHJhd0xheWVycyk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJl bmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5k ZXJlckNocm9taXVtOjpzZXRDb21wb3NpdGVPZmZzY3JlZW4pOgorICAgICAgICAoV2ViQ29yZTo6 TGF5ZXJSZW5kZXJlckNocm9taXVtOjp1c2VSZW5kZXJTdXJmYWNlKToKKyAgICAgICAgKFdlYkNv cmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6c2V0U2Npc3NvclRvUmVjdCk6CisgICAgICAgICog cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmg6CisgICAg ICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OmlzQ29tcG9zaXRpbmdPZmZzY3Jl ZW4pOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpnZXRPZmZzY3Jl ZW5MYXllclRleHR1cmUpOgorCiAyMDEwLTEyLTIxICBQYXZlbCBQb2Rpdmlsb3YgIDxwb2Rpdmls b3ZAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFl1cnkgU2VtaWtoYXRza3ku CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVu ZGVyZXJDaHJvbWl1bS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xh eWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKaW5kZXggODgyYmFhZTgyNzRlOGFmMjQzYTMzNjNjNjMz YjQzYTRjYTViNjhhNS4uZGE3ZDY5NzcxZmViOWM1NmJlMjJlZWQ1NDVhYzRlMmNmZmU2YzY3NCAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v TGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcApAQCAtMTA4LDYgKzEwOCw3IEBAIExheWVyUmVuZGVy ZXJDaHJvbWl1bTo6TGF5ZXJSZW5kZXJlckNocm9taXVtKFBhc3NSZWZQdHI8R3JhcGhpY3NDb250 ZXh0M0Q+IGNvbnRlCiAgICAgLCBtX2N1cnJlbnRTaGFkZXIoMCkKICAgICAsIG1fY3VycmVudFJl bmRlclN1cmZhY2UoMCkKICAgICAsIG1fb2Zmc2NyZWVuRnJhbWVidWZmZXJJZCgwKQorICAgICwg bV9jb21wb3NpdGVPZmZzY3JlZW4oZmFsc2UpCiAgICAgLCBtX2NvbnRleHQoY29udGV4dCkKICAg ICAsIG1fZGVmYXVsdFJlbmRlclN1cmZhY2UoMCkKIHsKQEAgLTE5Niw2ICsxOTcsMTEgQEAgdm9p ZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnByZXBhcmVUb0RyYXdMYXllcnMoY29uc3QgSW50UmVj dCYgdmlzaWJsZVJlY3QsIGNvbnMKICAgICAvLyBhbmQgdmlld3BvcnQuCiAgICAgaW50IHZpc2li bGVSZWN0V2lkdGggPSB2aXNpYmxlUmVjdC53aWR0aCgpOwogICAgIGludCB2aXNpYmxlUmVjdEhl aWdodCA9IHZpc2libGVSZWN0LmhlaWdodCgpOworCisgICAgaWYgKCFtX3Jvb3RMYXllci0+bV9y ZW5kZXJTdXJmYWNlKQorICAgICAgICBtX3Jvb3RMYXllci0+Y3JlYXRlUmVuZGVyU3VyZmFjZSgp OworICAgIG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QgPSBJbnRS ZWN0KDAsIDAsIHZpc2libGVSZWN0V2lkdGgsIHZpc2libGVSZWN0SGVpZ2h0KTsKKwogICAgIGlm ICh2aXNpYmxlUmVjdFdpZHRoICE9IG1fcm9vdExheWVyVGV4dHVyZVdpZHRoIHx8IHZpc2libGVS ZWN0SGVpZ2h0ICE9IG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCkgewogICAgICAgICBtX3Jvb3RM YXllclRleHR1cmVXaWR0aCA9IHZpc2libGVSZWN0V2lkdGg7CiAgICAgICAgIG1fcm9vdExheWVy VGV4dHVyZUhlaWdodCA9IHZpc2libGVSZWN0SGVpZ2h0OwpAQCAtMjkyLDExICsyOTgsOSBAQCB2 b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6dXBkYXRlUm9vdExheWVyVGV4dHVyZVJlY3QoY29u c3QgSW50UmVjdCYgdXBkYXRlUmVjdAogdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmRyYXdM YXllcnMoY29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnN0IEludFJlY3QmIGNvbnRlbnRS ZWN0KQogewogICAgIEFTU0VSVChtX2hhcmR3YXJlQ29tcG9zaXRpbmcpOworICAgIEFTU0VSVCht X3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlKTsKIAogICAgIG1fZGVmYXVsdFJlbmRlclN1cmZh Y2UgPSBtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlLmdldCgpOwotICAgIGlmICghbV9kZWZh dWx0UmVuZGVyU3VyZmFjZSkKLSAgICAgICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSA9IG1fcm9v dExheWVyLT5jcmVhdGVSZW5kZXJTdXJmYWNlKCk7Ci0gICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFj ZS0+bV9jb250ZW50UmVjdCA9IEludFJlY3QoMCwgMCwgbV9yb290TGF5ZXJUZXh0dXJlV2lkdGgs IG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCk7CiAKICAgICB1c2VSZW5kZXJTdXJmYWNlKG1fZGVm YXVsdFJlbmRlclN1cmZhY2UpOwogCkBAIC02NjEsNiArNjY1LDI1IEBAIHZvaWQgTGF5ZXJSZW5k ZXJlckNocm9taXVtOjp1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5ZXJDaHJvbWl1bSogbGF5ZXIs IGNvbnN0IFRyCiAgICAgICAgIHN0ZDo6c3RhYmxlX3NvcnQoJmRlc2NlbmRhbnRzLmF0KHRoaXNM YXllckluZGV4KSwgZGVzY2VuZGFudHMuZW5kKCksIGNvbXBhcmVMYXllclopOwogfQogCisvLyBE byBub3QgY2FsbCB0aGlzIGZ1bmN0aW9uIGJldHdlZW4gY2FsbGluZyBwcmVwYXJlVG9EcmF3TGF5 ZXJzKCkgYW5kIGRyYXdMYXllcnMoKSwKKy8vIGFzIHRoZSBtX3Jvb3RMYXllci0+cmVuZGVyU3Vy ZmFjZSBtYXkgYmUgaW5jb3JyZWN0bHkgZGVmaW5lZCBpbiB0aGlzIGNhc2UuCit2b2lkIExheWVy UmVuZGVyZXJDaHJvbWl1bTo6c2V0Q29tcG9zaXRlT2Zmc2NyZWVuKGJvb2wgY29tcG9zaXRlT2Zm c2NyZWVuKQoreworICAgIG1fY29tcG9zaXRlT2Zmc2NyZWVuID0gY29tcG9zaXRlT2Zmc2NyZWVu OworCisgICAgaWYgKCFtX3Jvb3RMYXllcikgeworICAgICAgICBtX2NvbXBvc2l0ZU9mZnNjcmVl biA9IGZhbHNlOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKG1fY29tcG9zaXRl T2Zmc2NyZWVuKSB7CisgICAgICAgIC8vIE5lZWQgdG8gZXhwbGljaXRseSBzZXQgYSBMYXllclJl bmRlcmVyQ2hyb21pdW0gZm9yIHRoZSBsYXllciB3aXRoIHRoZSBvZmZzY3JlZW4gdGV4dHVyZSwK KyAgICAgICAgLy8gb3IgZWxzZSB0aGUgY2FsbCB0byBwcmVwYXJlQ29udGVudHNUZXh0dXJlKCkg aW4gdXNlUmVuZGVyU3VyZmFjZSgpIHdpbGwgZmFpbC4KKyAgICAgICAgbV9yb290TGF5ZXItPnNl dExheWVyUmVuZGVyZXIodGhpcyk7CisgICAgfSBlbHNlIGlmIChtX3Jvb3RMYXllci0+bV9yZW5k ZXJTdXJmYWNlKQorICAgICAgICBtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlLnJlbGVhc2Uo KTsKK30KKwogYm9vbCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnVzZVJlbmRlclN1cmZhY2UoUmVu ZGVyU3VyZmFjZUNocm9taXVtKiByZW5kZXJTdXJmYWNlKQogewogICAgIGlmIChtX2N1cnJlbnRS ZW5kZXJTdXJmYWNlID09IHJlbmRlclN1cmZhY2UpCkBAIC02NjgsNyArNjkxLDcgQEAgYm9vbCBM YXllclJlbmRlcmVyQ2hyb21pdW06OnVzZVJlbmRlclN1cmZhY2UoUmVuZGVyU3VyZmFjZUNocm9t aXVtKiByZW5kZXJTdXJmYWMKIAogICAgIG1fY3VycmVudFJlbmRlclN1cmZhY2UgPSByZW5kZXJT dXJmYWNlOwogCi0gICAgaWYgKHJlbmRlclN1cmZhY2UgPT0gbV9kZWZhdWx0UmVuZGVyU3VyZmFj ZSkgeworICAgIGlmIChyZW5kZXJTdXJmYWNlID09IG1fZGVmYXVsdFJlbmRlclN1cmZhY2UgJiYg IW1fY29tcG9zaXRlT2Zmc2NyZWVuKSB7CiAgICAgICAgIEdMQyhtX2NvbnRleHQuZ2V0KCksIG1f Y29udGV4dC0+YmluZEZyYW1lYnVmZmVyKEdyYXBoaWNzQ29udGV4dDNEOjpGUkFNRUJVRkZFUiwg MCkpOwogICAgICAgICBzZXREcmF3Vmlld3BvcnRSZWN0KHJlbmRlclN1cmZhY2UtPm1fY29udGVu dFJlY3QsIHRydWUpOwogICAgICAgICByZXR1cm4gdHJ1ZTsKQEAgLTczNiw4ICs3NTksOSBAQCB2 b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6c2V0U2Npc3NvclRvUmVjdChjb25zdCBJbnRSZWN0 JiBzY2lzc29yUmVjdCkKICAgICBpbnQgc2Npc3NvclggPSBzY2lzc29yUmVjdC54KCkgLSBtX2N1 cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LngoKTsKICAgICAvLyBXaGVuIHJlbmRl cmluZyB0byB0aGUgZGVmYXVsdCByZW5kZXIgc3VyZmFjZSB3ZSdyZSByZW5kZXJpbmcgdXBzaWRl IGRvd24gc28gdGhlIHRvcAogICAgIC8vIG9mIHRoZSBHTCBzY2lzc29yIGlzIHRoZSBib3R0b20g b2Ygb3VyIGxheWVyLgorICAgIC8vIEJ1dCwgaWYgcmVuZGVyaW5nIHRvIG9mZnNjcmVlbiB0ZXh0 dXJlLCB3ZSByZXZlcnNlIG91ciBzZW5zZSBvZiAndXBzaWRlIGRvd24nLgogICAgIGludCBzY2lz c29yWTsKLSAgICBpZiAobV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9PSBtX2RlZmF1bHRSZW5kZXJT dXJmYWNlKQorICAgIGlmIChtX2N1cnJlbnRSZW5kZXJTdXJmYWNlID09IG1fZGVmYXVsdFJlbmRl clN1cmZhY2UgJiYgIW1fY29tcG9zaXRlT2Zmc2NyZWVuKQogICAgICAgICBzY2lzc29yWSA9IG1f Y3VycmVudFJlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QuaGVpZ2h0KCkgLSAoc2Npc3NvclJl Y3QuYm90dG9tKCkgLSBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LnkoKSk7 CiAgICAgZWxzZQogICAgICAgICBzY2lzc29yWSA9IHNjaXNzb3JSZWN0LnkoKSAtIG1fY3VycmVu dFJlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QueSgpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5k ZXggYzBlNjEwYTMwZmIxNDRjZTQ4ZTA0YzYzMjBlNDA5OTdjNjI3ZDMzZi4uODc2NmFjMWY0ZmM2 MDAzNTA5MjliZTFmNTEyN2QyYTkwODExNGYwNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAorKysgYi9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC04 OCw2ICs4OCwxMCBAQCBwdWJsaWM6CiAKICAgICBib29sIGhhcmR3YXJlQ29tcG9zaXRpbmcoKSBj b25zdCB7IHJldHVybiBtX2hhcmR3YXJlQ29tcG9zaXRpbmc7IH0KIAorICAgIHZvaWQgc2V0Q29t cG9zaXRlT2Zmc2NyZWVuKGJvb2wpOworICAgIGJvb2wgaXNDb21wb3NpdGluZ09mZnNjcmVlbigp IHsgcmV0dXJuIG1fY29tcG9zaXRlT2Zmc2NyZWVuOyB9CisgICAgTGF5ZXJUZXh0dXJlKiBnZXRP ZmZzY3JlZW5MYXllclRleHR1cmUoKSB7IHJldHVybiBtX2NvbXBvc2l0ZU9mZnNjcmVlbiA/IG1f cm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UtPm1fY29udGVudHNUZXh0dXJlLmdldCgpIDogMDsg fQorCiAgICAgdm9pZCBzZXRSb290TGF5ZXJDYW52YXNTaXplKGNvbnN0IEludFNpemUmKTsKIAog ICAgIEdyYXBoaWNzQ29udGV4dCogcm9vdExheWVyR3JhcGhpY3NDb250ZXh0KCkgY29uc3QgeyBy ZXR1cm4gbV9yb290TGF5ZXJHcmFwaGljc0NvbnRleHQuZ2V0KCk7IH0KQEAgLTE1NCw2ICsxNTgs NyBAQCBwcml2YXRlOgogICAgIFJlbmRlclN1cmZhY2VDaHJvbWl1bSogbV9jdXJyZW50UmVuZGVy U3VyZmFjZTsKIAogICAgIHVuc2lnbmVkIG1fb2Zmc2NyZWVuRnJhbWVidWZmZXJJZDsKKyAgICBi b29sIG1fY29tcG9zaXRlT2Zmc2NyZWVuOwogCiAjaWYgUExBVEZPUk0oU0tJQSkKICAgICBPd25Q dHI8c2tpYTo6UGxhdGZvcm1DYW52YXM+IG1fcm9vdExheWVyQ2FudmFzOwo= 77368 2010-12-23 13:56:37 -0800 2010-12-29 11:55:34 -0800 Patch bug-50833-20101223165634.patch text/plain 6751 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZDI1ZDg3ZjViMmNkZmU1MDc0NDEzNzI0ZTVmZmRmYzQ1NGY2NzRiMy4uMzAyZjk0ODYyZmVjN2I4 NjFmMjRmMzViNzg4NzI3YmY4MDYyMDgzYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAxMC0xMi0yMyAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9ydCB0 byBjb21wb3NpdG9yIHRvIGNvbXBvc2l0ZSB0byBvZmZzY3JlZW4gdGV4dHVyZS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwODMzCisKKyAgICAgICAg QSBwYXRjaCB0byBleHRlbmQgY29tcG9zaXRvciB0byBiZSBhYmxlIHRvIGNvbXBvc2l0ZSBpbnRv IGFuIG9mZnNjcmVlbiB0ZXh0dXJlIGluc3RlYWQKKyAgICAgICAgb2YganVzdCBkaXJlY3RseSB0 byB0aGUgZGlzcGxheSBidWZmZXIuIEJ1aWxkcyBvbiBSZW5kZXJTdXJmYWNlQ2hyb21pdW0gc3Vw cG9ydC4KKworICAgICAgICBFeHRlcm5hbCBiZWhhdmlvdXIgbm90IGNoYW5nZWQsIHNvIG5vIHRl c3RzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6 TGF5ZXJSZW5kZXJlckNocm9taXVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJD aHJvbWl1bTo6cHJlcGFyZVRvRHJhd0xheWVycyk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJl bmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5k ZXJlckNocm9taXVtOjpzZXRDb21wb3NpdGVPZmZzY3JlZW4pOgorICAgICAgICAoV2ViQ29yZTo6 TGF5ZXJSZW5kZXJlckNocm9taXVtOjp1c2VSZW5kZXJTdXJmYWNlKToKKyAgICAgICAgKFdlYkNv cmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6c2V0U2Npc3NvclRvUmVjdCk6CisgICAgICAgICog cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmg6CisgICAg ICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OmlzQ29tcG9zaXRpbmdPZmZzY3Jl ZW4pOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpnZXRPZmZzY3Jl ZW5MYXllclRleHR1cmUpOgorCiAyMDEwLTEyLTIzICBMdWNhcyBEZSBNYXJjaGkgIDxsdWNhcy5k ZW1hcmNoaUBwcm9mdXNpb24ubW9iaT4KIAogICAgICAgICBSZXZpZXdlZCBieSBLZW5uZXRoIFJv aGRlIENocmlzdGlhbnNlbi4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcAppbmRleCA4ODJiYWFlODI3 NGU4YWYyNDNhMzM2M2M2MzNiNDNhNGNhNWI2OGE1Li45MTQ1NDI5OTk0MzIyNjExNTM3ODRkMzA5 MGRlOGM4NGFmNTBlZjVmIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCkBAIC0xMDgsNiArMTA4 LDcgQEAgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpMYXllclJlbmRlcmVyQ2hyb21pdW0oUGFzc1Jl ZlB0cjxHcmFwaGljc0NvbnRleHQzRD4gY29udGUKICAgICAsIG1fY3VycmVudFNoYWRlcigwKQog ICAgICwgbV9jdXJyZW50UmVuZGVyU3VyZmFjZSgwKQogICAgICwgbV9vZmZzY3JlZW5GcmFtZWJ1 ZmZlcklkKDApCisgICAgLCBtX2NvbXBvc2l0ZU9mZnNjcmVlbihmYWxzZSkKICAgICAsIG1fY29u dGV4dChjb250ZXh0KQogICAgICwgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSgwKQogewpAQCAtMTk2 LDYgKzE5NywxMSBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6cHJlcGFyZVRvRHJhd0xh eWVycyhjb25zdCBJbnRSZWN0JiB2aXNpYmxlUmVjdCwgY29ucwogICAgIC8vIGFuZCB2aWV3cG9y dC4KICAgICBpbnQgdmlzaWJsZVJlY3RXaWR0aCA9IHZpc2libGVSZWN0LndpZHRoKCk7CiAgICAg aW50IHZpc2libGVSZWN0SGVpZ2h0ID0gdmlzaWJsZVJlY3QuaGVpZ2h0KCk7CisKKyAgICBpZiAo IW1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UpCisgICAgICAgIG1fcm9vdExheWVyLT5jcmVh dGVSZW5kZXJTdXJmYWNlKCk7CisgICAgbV9yb290TGF5ZXItPm1fcmVuZGVyU3VyZmFjZS0+bV9j b250ZW50UmVjdCA9IEludFJlY3QoMCwgMCwgdmlzaWJsZVJlY3RXaWR0aCwgdmlzaWJsZVJlY3RI ZWlnaHQpOworCiAgICAgaWYgKHZpc2libGVSZWN0V2lkdGggIT0gbV9yb290TGF5ZXJUZXh0dXJl V2lkdGggfHwgdmlzaWJsZVJlY3RIZWlnaHQgIT0gbV9yb290TGF5ZXJUZXh0dXJlSGVpZ2h0KSB7 CiAgICAgICAgIG1fcm9vdExheWVyVGV4dHVyZVdpZHRoID0gdmlzaWJsZVJlY3RXaWR0aDsKICAg ICAgICAgbV9yb290TGF5ZXJUZXh0dXJlSGVpZ2h0ID0gdmlzaWJsZVJlY3RIZWlnaHQ7CkBAIC0y OTIsMTEgKzI5OCw5IEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjp1cGRhdGVSb290TGF5 ZXJUZXh0dXJlUmVjdChjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0CiB2b2lkIExheWVyUmVuZGVy ZXJDaHJvbWl1bTo6ZHJhd0xheWVycyhjb25zdCBJbnRSZWN0JiB2aXNpYmxlUmVjdCwgY29uc3Qg SW50UmVjdCYgY29udGVudFJlY3QpCiB7CiAgICAgQVNTRVJUKG1faGFyZHdhcmVDb21wb3NpdGlu Zyk7CisgICAgQVNTRVJUKG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UpOwogCiAgICAgbV9k ZWZhdWx0UmVuZGVyU3VyZmFjZSA9IG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UuZ2V0KCk7 Ci0gICAgaWYgKCFtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKQotICAgICAgICBtX2RlZmF1bHRSZW5k ZXJTdXJmYWNlID0gbV9yb290TGF5ZXItPmNyZWF0ZVJlbmRlclN1cmZhY2UoKTsKLSAgICBtX2Rl ZmF1bHRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0ID0gSW50UmVjdCgwLCAwLCBtX3Jvb3RM YXllclRleHR1cmVXaWR0aCwgbV9yb290TGF5ZXJUZXh0dXJlSGVpZ2h0KTsKIAogICAgIHVzZVJl bmRlclN1cmZhY2UobV9kZWZhdWx0UmVuZGVyU3VyZmFjZSk7CiAKQEAgLTY2MSw2ICs2NjUsMjUg QEAgdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnVwZGF0ZUxheWVyc1JlY3Vyc2l2ZShMYXll ckNocm9taXVtKiBsYXllciwgY29uc3QgVHIKICAgICAgICAgc3RkOjpzdGFibGVfc29ydCgmZGVz Y2VuZGFudHMuYXQodGhpc0xheWVySW5kZXgpLCBkZXNjZW5kYW50cy5lbmQoKSwgY29tcGFyZUxh eWVyWik7CiB9CiAKKy8vIERvIG5vdCBjYWxsIHRoaXMgZnVuY3Rpb24gYmV0d2VlbiBjYWxsaW5n IHByZXBhcmVUb0RyYXdMYXllcnMoKSBhbmQgZHJhd0xheWVycygpLAorLy8gYXMgdGhlIG1fcm9v dExheWVyLT5yZW5kZXJTdXJmYWNlIG1heSBiZSBpbmNvcnJlY3RseSBkZWZpbmVkIGluIHRoaXMg Y2FzZS4KK3ZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpzZXRDb21wb3NpdGVPZmZzY3JlZW4o Ym9vbCBjb21wb3NpdGVPZmZzY3JlZW4pCit7CisgICAgbV9jb21wb3NpdGVPZmZzY3JlZW4gPSBj b21wb3NpdGVPZmZzY3JlZW47CisKKyAgICBpZiAoIW1fcm9vdExheWVyKSB7CisgICAgICAgIG1f Y29tcG9zaXRlT2Zmc2NyZWVuID0gZmFsc2U7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAg ICBpZiAobV9jb21wb3NpdGVPZmZzY3JlZW4pIHsKKyAgICAgICAgLy8gTmVlZCB0byBleHBsaWNp dGx5IHNldCBhIExheWVyUmVuZGVyZXJDaHJvbWl1bSBmb3IgdGhlIGxheWVyIHdpdGggdGhlIG9m ZnNjcmVlbiB0ZXh0dXJlLAorICAgICAgICAvLyBvciBlbHNlIHRoZSBjYWxsIHRvIHByZXBhcmVD b250ZW50c1RleHR1cmUoKSBpbiB1c2VSZW5kZXJTdXJmYWNlKCkgd2lsbCBmYWlsLgorICAgICAg ICBtX3Jvb3RMYXllci0+c2V0TGF5ZXJSZW5kZXJlcih0aGlzKTsKKyAgICB9IGVsc2UKKyAgICAg ICAgbV9yb290TGF5ZXItPm1fcmVuZGVyU3VyZmFjZS5jbGVhcigpOworfQorCiBib29sIExheWVy UmVuZGVyZXJDaHJvbWl1bTo6dXNlUmVuZGVyU3VyZmFjZShSZW5kZXJTdXJmYWNlQ2hyb21pdW0q IHJlbmRlclN1cmZhY2UpCiB7CiAgICAgaWYgKG1fY3VycmVudFJlbmRlclN1cmZhY2UgPT0gcmVu ZGVyU3VyZmFjZSkKQEAgLTY2OCw3ICs2OTEsNyBAQCBib29sIExheWVyUmVuZGVyZXJDaHJvbWl1 bTo6dXNlUmVuZGVyU3VyZmFjZShSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIHJlbmRlclN1cmZhYwog CiAgICAgbV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9IHJlbmRlclN1cmZhY2U7CiAKLSAgICBpZiAo cmVuZGVyU3VyZmFjZSA9PSBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKSB7CisgICAgaWYgKHJlbmRl clN1cmZhY2UgPT0gbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSAmJiAhbV9jb21wb3NpdGVPZmZzY3Jl ZW4pIHsKICAgICAgICAgR0xDKG1fY29udGV4dC5nZXQoKSwgbV9jb250ZXh0LT5iaW5kRnJhbWVi dWZmZXIoR3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSLCAwKSk7CiAgICAgICAgIHNldERy YXdWaWV3cG9ydFJlY3QocmVuZGVyU3VyZmFjZS0+bV9jb250ZW50UmVjdCwgdHJ1ZSk7CiAgICAg ICAgIHJldHVybiB0cnVlOwpAQCAtNzM2LDggKzc1OSw5IEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNo cm9taXVtOjpzZXRTY2lzc29yVG9SZWN0KGNvbnN0IEludFJlY3QmIHNjaXNzb3JSZWN0KQogICAg IGludCBzY2lzc29yWCA9IHNjaXNzb3JSZWN0LngoKSAtIG1fY3VycmVudFJlbmRlclN1cmZhY2Ut Pm1fY29udGVudFJlY3QueCgpOwogICAgIC8vIFdoZW4gcmVuZGVyaW5nIHRvIHRoZSBkZWZhdWx0 IHJlbmRlciBzdXJmYWNlIHdlJ3JlIHJlbmRlcmluZyB1cHNpZGUgZG93biBzbyB0aGUgdG9wCiAg ICAgLy8gb2YgdGhlIEdMIHNjaXNzb3IgaXMgdGhlIGJvdHRvbSBvZiBvdXIgbGF5ZXIuCisgICAg Ly8gQnV0LCBpZiByZW5kZXJpbmcgdG8gb2Zmc2NyZWVuIHRleHR1cmUsIHdlIHJldmVyc2Ugb3Vy IHNlbnNlIG9mICd1cHNpZGUgZG93bicuCiAgICAgaW50IHNjaXNzb3JZOwotICAgIGlmIChtX2N1 cnJlbnRSZW5kZXJTdXJmYWNlID09IG1fZGVmYXVsdFJlbmRlclN1cmZhY2UpCisgICAgaWYgKG1f Y3VycmVudFJlbmRlclN1cmZhY2UgPT0gbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSAmJiAhbV9jb21w b3NpdGVPZmZzY3JlZW4pCiAgICAgICAgIHNjaXNzb3JZID0gbV9jdXJyZW50UmVuZGVyU3VyZmFj ZS0+bV9jb250ZW50UmVjdC5oZWlnaHQoKSAtIChzY2lzc29yUmVjdC5ib3R0b20oKSAtIG1fY3Vy cmVudFJlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QueSgpKTsKICAgICBlbHNlCiAgICAgICAg IHNjaXNzb3JZID0gc2Npc3NvclJlY3QueSgpIC0gbV9jdXJyZW50UmVuZGVyU3VyZmFjZS0+bV9j b250ZW50UmVjdC55KCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAppbmRleCBjMGU2MTBhMzBmYjE0NGNl NDhlMDRjNjMyMGU0MDk5N2M2MjdkMzNmLi44NzY2YWMxZjRmYzYwMDM1MDkyOWJlMWY1MTI3ZDJh OTA4MTE0ZjA2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKQEAgLTg4LDYgKzg4LDEwIEBAIHB1Ymxp YzoKIAogICAgIGJvb2wgaGFyZHdhcmVDb21wb3NpdGluZygpIGNvbnN0IHsgcmV0dXJuIG1faGFy ZHdhcmVDb21wb3NpdGluZzsgfQogCisgICAgdm9pZCBzZXRDb21wb3NpdGVPZmZzY3JlZW4oYm9v bCk7CisgICAgYm9vbCBpc0NvbXBvc2l0aW5nT2Zmc2NyZWVuKCkgeyByZXR1cm4gbV9jb21wb3Np dGVPZmZzY3JlZW47IH0KKyAgICBMYXllclRleHR1cmUqIGdldE9mZnNjcmVlbkxheWVyVGV4dHVy ZSgpIHsgcmV0dXJuIG1fY29tcG9zaXRlT2Zmc2NyZWVuID8gbV9yb290TGF5ZXItPm1fcmVuZGVy U3VyZmFjZS0+bV9jb250ZW50c1RleHR1cmUuZ2V0KCkgOiAwOyB9CisKICAgICB2b2lkIHNldFJv b3RMYXllckNhbnZhc1NpemUoY29uc3QgSW50U2l6ZSYpOwogCiAgICAgR3JhcGhpY3NDb250ZXh0 KiByb290TGF5ZXJHcmFwaGljc0NvbnRleHQoKSBjb25zdCB7IHJldHVybiBtX3Jvb3RMYXllckdy YXBoaWNzQ29udGV4dC5nZXQoKTsgfQpAQCAtMTU0LDYgKzE1OCw3IEBAIHByaXZhdGU6CiAgICAg UmVuZGVyU3VyZmFjZUNocm9taXVtKiBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlOwogCiAgICAgdW5z aWduZWQgbV9vZmZzY3JlZW5GcmFtZWJ1ZmZlcklkOworICAgIGJvb2wgbV9jb21wb3NpdGVPZmZz Y3JlZW47CiAKICNpZiBQTEFURk9STShTS0lBKQogICAgIE93blB0cjxza2lhOjpQbGF0Zm9ybUNh bnZhcz4gbV9yb290TGF5ZXJDYW52YXM7Cg== 77636 2010-12-29 11:55:41 -0800 2010-12-29 13:13:04 -0800 Patch bug-50833-20101229145412.patch text/plain 10433 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MTFhODllMGU1MjBkMTc1ODNiYmIzZjQxN2IzMjkxY2QzZGYyMDczNy4uNzNiZmNjMmY0ZGI2M2Iw NDAzZGU2Zjc0NWRlYTNlOTI1NTY1ZDIyMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAxMC0xMi0yOSAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9ydCB0 byBjb21wb3NpdG9yIHRvIGNvbXBvc2l0ZSB0byBvZmZzY3JlZW4gdGV4dHVyZS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwODMzCisKKyAgICAgICAg QSBwYXRjaCB0byBleHRlbmQgY29tcG9zaXRvciB0byBiZSBhYmxlIHRvIGNvbXBvc2l0ZSBpbnRv IGFuIG9mZnNjcmVlbiB0ZXh0dXJlIGluc3RlYWQKKyAgICAgICAgb2YganVzdCBkaXJlY3RseSB0 byB0aGUgZGlzcGxheSBidWZmZXIuIEJ1aWxkcyBvbiBSZW5kZXJTdXJmYWNlQ2hyb21pdW0gc3Vw cG9ydC4KKyAgICAgICAgRXhwbGljaXRseSByZXNldHMgYWxwaGEgY2hhbm5lbCBiZWZvcmUgcmVu ZGVyaW5nIHRvIGRpc3BsYXkuCisgICAgICAgICoqKiBUZXN0IGNvZGUgbGVmdCBpbiBmb3IgZGlz Y3Vzc2lvbiBvbmx5LiAqKioKKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRl cmVyQ2hyb21pdW06OkxheWVyUmVuZGVyZXJDaHJvbWl1bSk6CisgICAgICAgIChXZWJDb3JlOjpM YXllclJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5 ZXJSZW5kZXJlckNocm9taXVtOjpzZXRDb21wb3NpdGVPZmZzY3JlZW4pOgorICAgICAgICAoV2Vi Q29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpjb3B5T2Zmc2NyZWVuVGV4dHVyZVRvRGlzcGxh eSk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OnVzZVJlbmRlclN1 cmZhY2UpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpkcmF3TGF5 ZXIpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpzZXRTY2lzc29y VG9SZWN0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uaDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6 aXNDb21wb3NpdGluZ09mZnNjcmVlbik6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVy Q2hyb21pdW06OmdldE9mZnNjcmVlbkxheWVyVGV4dHVyZSk6CisKIDIwMTAtMTItMjggIEFsZXhh bmRlciBQYXZsb3YgIDxhcGF2bG92QGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBi eSBQYXZlbCBGZWxkbWFuLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCmluZGV4IDBmNTY3NzcwYTYw ZWZiNDU0M2VjZjQwZTU3NzQ3NzFlNTMxNDhkNTMuLmU2NjFhY2EwMjY3ODBkMWJiMDc0ZmY5NDZi Yjg4OGNjY2QyNjg3NjAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKQEAgLTEwNyw2ICsxMDcs NyBAQCBMYXllclJlbmRlcmVyQ2hyb21pdW06OkxheWVyUmVuZGVyZXJDaHJvbWl1bShQYXNzUmVm UHRyPEdyYXBoaWNzQ29udGV4dDNEPiBjb250ZQogICAgICwgbV9jdXJyZW50U2hhZGVyKDApCiAg ICAgLCBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlKDApCiAgICAgLCBtX29mZnNjcmVlbkZyYW1lYnVm ZmVySWQoMCkKKyAgICAsIG1fY29tcG9zaXRlT2Zmc2NyZWVuKGZhbHNlKQogICAgICwgbV9jb250 ZXh0KGNvbnRleHQpCiAgICAgLCBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKDApCiB7CkBAIC0yMjgs NiArMjI5LDExIEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKGNvbnN0 IEludFJlY3QmIHZpc2libGVSZWN0LCBjb25zdCBJbnRSZWN0CiAgICAgLy8gYW5kIHZpZXdwb3J0 LgogICAgIGludCB2aXNpYmxlUmVjdFdpZHRoID0gdmlzaWJsZVJlY3Qud2lkdGgoKTsKICAgICBp bnQgdmlzaWJsZVJlY3RIZWlnaHQgPSB2aXNpYmxlUmVjdC5oZWlnaHQoKTsKKworICAgIGlmICgh bV9yb290TGF5ZXItPm1fcmVuZGVyU3VyZmFjZSkKKyAgICAgICAgbV9yb290TGF5ZXItPmNyZWF0 ZVJlbmRlclN1cmZhY2UoKTsKKyAgICBtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlLT5tX2Nv bnRlbnRSZWN0ID0gSW50UmVjdCgwLCAwLCB2aXNpYmxlUmVjdFdpZHRoLCB2aXNpYmxlUmVjdEhl aWdodCk7CisKICAgICBpZiAodmlzaWJsZVJlY3RXaWR0aCAhPSBtX3Jvb3RMYXllclRleHR1cmVX aWR0aCB8fCB2aXNpYmxlUmVjdEhlaWdodCAhPSBtX3Jvb3RMYXllclRleHR1cmVIZWlnaHQpIHsK ICAgICAgICAgbV9yb290TGF5ZXJUZXh0dXJlV2lkdGggPSB2aXNpYmxlUmVjdFdpZHRoOwogICAg ICAgICBtX3Jvb3RMYXllclRleHR1cmVIZWlnaHQgPSB2aXNpYmxlUmVjdEhlaWdodDsKQEAgLTI1 MiwxNiArMjU4LDE2IEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKGNv bnN0IEludFJlY3QmIHZpc2libGVSZWN0LCBjb25zdCBJbnRSZWN0CiAKICAgICBtX3Njcm9sbFBv c2l0aW9uID0gc2Nyb2xsUG9zaXRpb247CiAKKyAgICBBU1NFUlQobV9yb290TGF5ZXItPm1fcmVu ZGVyU3VyZmFjZSk7CiAgICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSA9IG1fcm9vdExheWVyLT5t X3JlbmRlclN1cmZhY2UuZ2V0KCk7Ci0gICAgaWYgKCFtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKQot ICAgICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlID0gbV9yb290TGF5ZXItPmNyZWF0ZVJlbmRl clN1cmZhY2UoKTsKLSAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0ID0g SW50UmVjdCgwLCAwLCBtX3Jvb3RMYXllclRleHR1cmVXaWR0aCwgbV9yb290TGF5ZXJUZXh0dXJl SGVpZ2h0KTsKIAogICAgIHVzZVJlbmRlclN1cmZhY2UobV9kZWZhdWx0UmVuZGVyU3VyZmFjZSk7 CiAKICAgICAvLyBDbGVhciB0byBibHVlIHRvIG1ha2UgaXQgZWFzaWVyIHRvIHNwb3QgdW5yZW5k ZXJlZCByZWdpb25zLgogICAgIG1fY29udGV4dC0+Y2xlYXJDb2xvcigwLCAwLCAxLCAxKTsKKyAg ICBtX2NvbnRleHQtPmNvbG9yTWFzayh0cnVlLCB0cnVlLCB0cnVlLCB0cnVlKTsKICAgICBtX2Nv bnRleHQtPmNsZWFyKEdyYXBoaWNzQ29udGV4dDNEOjpDT0xPUl9CVUZGRVJfQklUKTsKKyAgICBt X2NvbnRleHQtPmNvbG9yTWFzayh0cnVlLCB0cnVlLCB0cnVlLCBmYWxzZSk7CiAKICAgICB1cGRh dGVBbmREcmF3Um9vdExheWVyKHRpbGVQYWludCwgc2Nyb2xsYmFyUGFpbnQsIHZpc2libGVSZWN0 LCBjb250ZW50UmVjdCk7CiAKQEAgLTYxNSw2ICs2MjEsNDkgQEAgdm9pZCBMYXllclJlbmRlcmVy Q2hyb21pdW06OnVwZGF0ZUxheWVyc1JlY3Vyc2l2ZShMYXllckNocm9taXVtKiBsYXllciwgY29u c3QgVHIKICAgICAgICAgc3RkOjpzdGFibGVfc29ydCgmZGVzY2VuZGFudHMuYXQodGhpc0xheWVy SW5kZXgpLCBkZXNjZW5kYW50cy5lbmQoKSwgY29tcGFyZUxheWVyWik7CiB9CiAKK3ZvaWQgTGF5 ZXJSZW5kZXJlckNocm9taXVtOjpzZXRDb21wb3NpdGVPZmZzY3JlZW4oYm9vbCBjb21wb3NpdGVP ZmZzY3JlZW4pCit7CisgICAgbV9jb21wb3NpdGVPZmZzY3JlZW4gPSBjb21wb3NpdGVPZmZzY3Jl ZW47CisKKyAgICBpZiAoIW1fcm9vdExheWVyKSB7CisgICAgICAgIG1fY29tcG9zaXRlT2Zmc2Ny ZWVuID0gZmFsc2U7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBpZiAobV9jb21wb3Np dGVPZmZzY3JlZW4pIHsKKyAgICAgICAgLy8gTmVlZCB0byBleHBsaWNpdGx5IHNldCBhIExheWVy UmVuZGVyZXJDaHJvbWl1bSBmb3IgdGhlIGxheWVyIHdpdGggdGhlIG9mZnNjcmVlbiB0ZXh0dXJl LAorICAgICAgICAvLyBvciBlbHNlIHRoZSBjYWxsIHRvIHByZXBhcmVDb250ZW50c1RleHR1cmUo KSBpbiB1c2VSZW5kZXJTdXJmYWNlKCkgd2lsbCBmYWlsLgorICAgICAgICBtX3Jvb3RMYXllci0+ c2V0TGF5ZXJSZW5kZXJlcih0aGlzKTsKKyAgICB9IGVsc2UKKyAgICAgICAgbV9yb290TGF5ZXIt Pm1fcmVuZGVyU3VyZmFjZS5jbGVhcigpOworfQorCisvLyBUT0RPOiBSZW1vdmUgdGhpcyBmdW5j dGlvbiAuLi4gdGVzdCBjb2RlIG9ubHkuCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6Y29w eU9mZnNjcmVlblRleHR1cmVUb0Rpc3BsYXkoKQoreworICAgIGlmIChtX2NvbXBvc2l0ZU9mZnNj cmVlbikgeworICAgICAgICBtYWtlQ29udGV4dEN1cnJlbnQoKTsKKyAgICAgICAgR0xDKG1fY29u dGV4dCwgbV9jb250ZXh0LT5iaW5kRnJhbWVidWZmZXIoR3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1F QlVGRkVSLCAwKSk7CisgICAgICAgIHNldERyYXdWaWV3cG9ydFJlY3QobV9kZWZhdWx0UmVuZGVy U3VyZmFjZS0+bV9jb250ZW50UmVjdCwgdHJ1ZSk7CisKKyAgICAgICAgLy8gUmVzZXQgYWxwaGEg Y2hhbm5lbCB0byAxLjAuCisgICAgICAgIG1fY29udGV4dC0+Y29sb3JNYXNrKGZhbHNlLCBmYWxz ZSwgZmFsc2UsIHRydWUpOworICAgICAgICBtX2NvbnRleHQtPmNsZWFyQ29sb3IoMCwgMCwgMCwg MSk7CisgICAgICAgIG1fY29udGV4dC0+Y2xlYXIoR3JhcGhpY3NDb250ZXh0M0Q6OkNPTE9SX0JV RkZFUl9CSVQpOworICAgICAgICBtX2NvbnRleHQtPmNvbG9yTWFzayh0cnVlLCB0cnVlLCB0cnVl LCBmYWxzZSk7CisKKyAgICAgICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZS0+bV9kcmF3VHJhbnNm b3JtLm1ha2VJZGVudGl0eSgpOworICAgICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5tX2Ry YXdUcmFuc2Zvcm0udHJhbnNsYXRlM2QoMC41ICogbV9kZWZhdWx0UmVuZGVyU3VyZmFjZS0+bV9j b250ZW50UmVjdC53aWR0aCgpLCAwLjUgKiBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5tX2NvbnRl bnRSZWN0LmhlaWdodCgpLCAwKTsKKworICAgICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5t X2RyYXdPcGFjaXR5ID0gMTsKKworICAgICAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5kcmF3 KCk7CisKKyAgICAgICAgbV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9IDA7IC8vIE5lZWQgdG8gZG8g dGhpcywgb3IgZWxzZSBuZXh0IGNhbGwgdG8gdXNlUmVuZGVyU3VyZmFjZSB3aWxsIHN0aWxsIGJl IGJvdW5kIHRvCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBmcmFtZUJ1 ZmZlciAwLCBhbmQgdXBkYXRlcyB3aWxsIGZhaWwuCisgICAgfQorfQorCiBib29sIExheWVyUmVu ZGVyZXJDaHJvbWl1bTo6dXNlUmVuZGVyU3VyZmFjZShSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIHJl bmRlclN1cmZhY2UpCiB7CiAgICAgaWYgKG1fY3VycmVudFJlbmRlclN1cmZhY2UgPT0gcmVuZGVy U3VyZmFjZSkKQEAgLTYyMiw3ICs2NzEsNyBAQCBib29sIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6 dXNlUmVuZGVyU3VyZmFjZShSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIHJlbmRlclN1cmZhYwogCiAg ICAgbV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9IHJlbmRlclN1cmZhY2U7CiAKLSAgICBpZiAocmVu ZGVyU3VyZmFjZSA9PSBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKSB7CisgICAgaWYgKHJlbmRlclN1 cmZhY2UgPT0gbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSAmJiAhbV9jb21wb3NpdGVPZmZzY3JlZW4p IHsKICAgICAgICAgR0xDKG1fY29udGV4dC5nZXQoKSwgbV9jb250ZXh0LT5iaW5kRnJhbWVidWZm ZXIoR3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSLCAwKSk7CiAgICAgICAgIHNldERyYXdW aWV3cG9ydFJlY3QocmVuZGVyU3VyZmFjZS0+bV9jb250ZW50UmVjdCwgdHJ1ZSk7CiAgICAgICAg IHJldHVybiB0cnVlOwpAQCAtNjQ5LDYgKzY5OCw3IEBAIGJvb2wgTGF5ZXJSZW5kZXJlckNocm9t aXVtOjp1c2VSZW5kZXJTdXJmYWNlKFJlbmRlclN1cmZhY2VDaHJvbWl1bSogcmVuZGVyU3VyZmFj CiB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6ZHJhd0xheWVyKExheWVyQ2hyb21pdW0qIGxh eWVyLCBSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIHRhcmdldFN1cmZhY2UpCiB7CiAgICAgaWYgKGxh eWVyLT5tX3JlbmRlclN1cmZhY2UgJiYgbGF5ZXItPm1fcmVuZGVyU3VyZmFjZSAhPSB0YXJnZXRT dXJmYWNlKSB7CisgICAgICAgIEdMQyhtX2NvbnRleHQuZ2V0KCksIG1fY29udGV4dC0+Y29sb3JN YXNrKHRydWUsIHRydWUsIHRydWUsIGZhbHNlKSk7CiAgICAgICAgIGxheWVyLT5tX3JlbmRlclN1 cmZhY2UtPmRyYXcoKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KQEAgLTY3NCw2ICs3MjQsNyBA QCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6ZHJhd0xheWVyKExheWVyQ2hyb21pdW0qIGxh eWVyLCBSZW5kZXJTdXJmYWNlQ2hyb21pdQogICAgICAgICAvLyBVcGRhdGUgdGhlIGNvbnRlbnRz IG9mIHRoZSBsYXllciBpZiBuZWNlc3NhcnkuCiAgICAgICAgIGxheWVyLT51cGRhdGVDb250ZW50 c0lmRGlydHkoKTsKICAgICAgICAgbV9jb250ZXh0LT5tYWtlQ29udGV4dEN1cnJlbnQoKTsKKyAg ICAgICAgR0xDKG1fY29udGV4dC5nZXQoKSwgbV9jb250ZXh0LT5jb2xvck1hc2sodHJ1ZSwgdHJ1 ZSwgdHJ1ZSwgZmFsc2UpKTsKICAgICAgICAgbGF5ZXItPmRyYXcoKTsKICAgICB9CiAKQEAgLTY5 MCw4ICs3NDEsOSBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6c2V0U2Npc3NvclRvUmVj dChjb25zdCBJbnRSZWN0JiBzY2lzc29yUmVjdCkKICAgICBpbnQgc2Npc3NvclggPSBzY2lzc29y UmVjdC54KCkgLSBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LngoKTsKICAg ICAvLyBXaGVuIHJlbmRlcmluZyB0byB0aGUgZGVmYXVsdCByZW5kZXIgc3VyZmFjZSB3ZSdyZSBy ZW5kZXJpbmcgdXBzaWRlIGRvd24gc28gdGhlIHRvcAogICAgIC8vIG9mIHRoZSBHTCBzY2lzc29y IGlzIHRoZSBib3R0b20gb2Ygb3VyIGxheWVyLgorICAgIC8vIEJ1dCwgaWYgcmVuZGVyaW5nIHRv IG9mZnNjcmVlbiB0ZXh0dXJlLCB3ZSByZXZlcnNlIG91ciBzZW5zZSBvZiAndXBzaWRlIGRvd24n LgogICAgIGludCBzY2lzc29yWTsKLSAgICBpZiAobV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9PSBt X2RlZmF1bHRSZW5kZXJTdXJmYWNlKQorICAgIGlmIChtX2N1cnJlbnRSZW5kZXJTdXJmYWNlID09 IG1fZGVmYXVsdFJlbmRlclN1cmZhY2UgJiYgIW1fY29tcG9zaXRlT2Zmc2NyZWVuKQogICAgICAg ICBzY2lzc29yWSA9IG1fY3VycmVudFJlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QuaGVpZ2h0 KCkgLSAoc2Npc3NvclJlY3QuYm90dG9tKCkgLSBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2Nv bnRlbnRSZWN0LnkoKSk7CiAgICAgZWxzZQogICAgICAgICBzY2lzc29yWSA9IHNjaXNzb3JSZWN0 LnkoKSAtIG1fY3VycmVudFJlbmRlclN1cmZhY2UtPm1fY29udGVudFJlY3QueSgpOwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hy b21pdW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmgKaW5kZXggNjQ3NDI2OWRmYzI1OGE1NTBhM2Q0ZTY1OTZiN2M3ZWYzOTA2MzQ0 MC4uZWM5ZGQxMDUwY2RkZjM3ZGVlMDEwZTM0OWQ1YTJkZTMwMmFlOGFmNyAxMDA2NDQKLS0tIGEv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0u aAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5oCkBAIC04Nyw2ICs4NywxMSBAQCBwdWJsaWM6CiAKICAgICBib29sIGhhcmR3YXJl Q29tcG9zaXRpbmcoKSBjb25zdCB7IHJldHVybiBtX2hhcmR3YXJlQ29tcG9zaXRpbmc7IH0KIAor ICAgIHZvaWQgc2V0Q29tcG9zaXRlT2Zmc2NyZWVuKGJvb2wpOworICAgIGJvb2wgaXNDb21wb3Np dGluZ09mZnNjcmVlbigpIHsgcmV0dXJuIG1fY29tcG9zaXRlT2Zmc2NyZWVuOyB9CisgICAgTGF5 ZXJUZXh0dXJlKiBnZXRPZmZzY3JlZW5MYXllclRleHR1cmUoKSB7IHJldHVybiBtX2NvbXBvc2l0 ZU9mZnNjcmVlbiA/IG1fcm9vdExheWVyLT5tX3JlbmRlclN1cmZhY2UtPm1fY29udGVudHNUZXh0 dXJlLmdldCgpIDogMDsgfQorICAgIHZvaWQgY29weU9mZnNjcmVlblRleHR1cmVUb0Rpc3BsYXko KTsKKwogICAgIHZvaWQgc2V0Um9vdExheWVyQ2FudmFzU2l6ZShjb25zdCBJbnRTaXplJik7CiAK ICAgICBHcmFwaGljc0NvbnRleHQqIHJvb3RMYXllckdyYXBoaWNzQ29udGV4dCgpIGNvbnN0IHsg cmV0dXJuIG1fcm9vdExheWVyR3JhcGhpY3NDb250ZXh0LmdldCgpOyB9CkBAIC0xNjAsNiArMTY1 LDcgQEAgcHJpdmF0ZToKICAgICBSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIG1fY3VycmVudFJlbmRl clN1cmZhY2U7CiAKICAgICB1bnNpZ25lZCBtX29mZnNjcmVlbkZyYW1lYnVmZmVySWQ7CisgICAg Ym9vbCBtX2NvbXBvc2l0ZU9mZnNjcmVlbjsKIAogI2lmIFBMQVRGT1JNKFNLSUEpCiAgICAgT3du UHRyPHNraWE6OlBsYXRmb3JtQ2FudmFzPiBtX3Jvb3RMYXllckNhbnZhczsKZGlmZiAtLWdpdCBh L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmlu ZGV4IDUzMzhlYjdmN2IzYmYzYzJiOTU4ODg0ZWFhMmJmZjlhNGRiNzc2YjUuLjA5M2I4NzVlMTJl NWEyZjg4ZjUyYzk1NzA1MzRhOGIxZjE1NWVhODYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1 IEBACisyMDEwLTEyLTI5ICBXLiBKYW1lcyBNYWNMZWFuICA8d2ptYWNsZWFuQGNocm9taXVtLm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbY2hy b21pdW1dIEFkZCBzdXBwb3J0IHRvIGNvbXBvc2l0b3IgdG8gY29tcG9zaXRlIHRvIG9mZnNjcmVl biB0ZXh0dXJlLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NTA4MzMKKworICAgICAgICBUZXN0IGNvZGUgdG8gaWxsdXN0cmF0ZSB1c2Ugb2YgY29tcG9z aXRpbmcgdG8gb2Zmc2NyZWVuIFJlbmRlclN1cmZhY2UuCisKKyAgICAgICAgKiBzcmMvV2ViVmll d0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6ZG9Db21wb3NpdGUpOgor CiAyMDEwLTEyLTI5ICBaaGUgU3UgIDxzdXpoZUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YlZpZXdJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4 IGE3YzRhYTFjZThkOTI2OWQ0ZWMwNjc2YmRhZDNjYmU4YTljYWVkNTkuLmE2YTUwNjMyZDgxMzVm ODA2ZWNkNzQ0YWJhOWE2NmUxOTU0NTEwYzUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwu Y3BwCkBAIC0yMzg3LDcgKzIzODcsOSBAQCB2b2lkIFdlYlZpZXdJbXBsOjpkb0NvbXBvc2l0ZSgp CiAgICAgV2ViVmlld0ltcGxUaWxlUGFpbnRJbnRlcmZhY2UgdGlsZVBhaW50KHRoaXMpOwogCiAg ICAgV2ViVmlld0ltcGxTY3JvbGxiYXJQYWludEludGVyZmFjZSBzY3JvbGxiYXJQYWludCh0aGlz KTsKKyAgICBtX2xheWVyUmVuZGVyZXItPnNldENvbXBvc2l0ZU9mZnNjcmVlbih0cnVlKTsgLy8g VE9ETzogcmVtb3ZlIHRoaXMsIHRlc3QgY29kZS4gTXVzdCB3b3JrICd0cnVlJyBvciAnZmFsc2Un LgogICAgIG1fbGF5ZXJSZW5kZXJlci0+ZHJhd0xheWVycyh2aXNpYmxlUmVjdCwgY29udGVudFJl Y3QsIHNjcm9sbCwgdGlsZVBhaW50LCBzY3JvbGxiYXJQYWludCk7CisgICAgbV9sYXllclJlbmRl cmVyLT5jb3B5T2Zmc2NyZWVuVGV4dHVyZVRvRGlzcGxheSgpOyAvLyBUT0RPOiBSZW1vdmUgdGhp cywgdGVzdCBjb2RlLgogfQogCiB2b2lkIFdlYlZpZXdJbXBsOjpyZWFsbG9jYXRlUmVuZGVyZXIo KQo= 77640 2010-12-29 13:13:10 -0800 2011-01-04 16:54:05 -0800 Patch bug-50833-20101229161140.patch text/plain 7638 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MTFhODllMGU1MjBkMTc1ODNiYmIzZjQxN2IzMjkxY2QzZGYyMDczNy4uYzBhYWViY2E2MmYzY2Qz ODhmNWM1NzZkOTIyNDJiYzAxNzcyOWFkZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNSBAQAorMjAxMC0xMi0yOSAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9ydCB0 byBjb21wb3NpdG9yIHRvIGNvbXBvc2l0ZSB0byBvZmZzY3JlZW4gdGV4dHVyZS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwODMzCisKKyAgICAgICAg QSBwYXRjaCB0byBleHRlbmQgY29tcG9zaXRvciB0byBiZSBhYmxlIHRvIGNvbXBvc2l0ZSBpbnRv IGFuIG9mZnNjcmVlbiB0ZXh0dXJlIGluc3RlYWQKKyAgICAgICAgb2YganVzdCBkaXJlY3RseSB0 byB0aGUgZGlzcGxheSBidWZmZXIuIEJ1aWxkcyBvbiBSZW5kZXJTdXJmYWNlQ2hyb21pdW0gc3Vw cG9ydC4KKyAgICAgICAgRXhwbGljaXRseSByZXNldHMgYWxwaGEgY2hhbm5lbCBiZWZvcmUgcmVu ZGVyaW5nIHRvIGRpc3BsYXkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5k ZXJlckNocm9taXVtOjpMYXllclJlbmRlcmVyQ2hyb21pdW0pOgorICAgICAgICAoV2ViQ29yZTo6 TGF5ZXJSZW5kZXJlckNocm9taXVtOjp1cGRhdGVBbmREcmF3Um9vdExheWVyKToKKyAgICAgICAg KFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6ZHJhd0xheWVycyk6CisgICAgICAgIChX ZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OnNldENvbXBvc2l0ZU9mZnNjcmVlbik6Cisg ICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OnVzZVJlbmRlclN1cmZhY2Up OgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpzZXRTY2lzc29yVG9S ZWN0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVy Q2hyb21pdW0uaDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6aXND b21wb3NpdGluZ09mZnNjcmVlbik6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hy b21pdW06OmdldE9mZnNjcmVlbkxheWVyVGV4dHVyZSk6CisKIDIwMTAtMTItMjggIEFsZXhhbmRl ciBQYXZsb3YgIDxhcGF2bG92QGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBQ YXZlbCBGZWxkbWFuLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCmluZGV4IDBmNTY3NzcwYTYwZWZi NDU0M2VjZjQwZTU3NzQ3NzFlNTMxNDhkNTMuLjhkNzdiZWFlOWI1MzYyMjczYjM4YTk4ZTljNmM0 MzczYjQ0NmY0YjQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKQEAgLTEwNyw2ICsxMDcsNyBA QCBMYXllclJlbmRlcmVyQ2hyb21pdW06OkxheWVyUmVuZGVyZXJDaHJvbWl1bShQYXNzUmVmUHRy PEdyYXBoaWNzQ29udGV4dDNEPiBjb250ZQogICAgICwgbV9jdXJyZW50U2hhZGVyKDApCiAgICAg LCBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlKDApCiAgICAgLCBtX29mZnNjcmVlbkZyYW1lYnVmZmVy SWQoMCkKKyAgICAsIG1fY29tcG9zaXRlT2Zmc2NyZWVuKGZhbHNlKQogICAgICwgbV9jb250ZXh0 KGNvbnRleHQpCiAgICAgLCBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKDApCiB7CkBAIC0xODAsMTAg KzE4MSw2IEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjppbnZhbGlkYXRlUm9vdExheWVy UmVjdChjb25zdCBJbnRSZWN0JiBkaXJ0eVJlY3QsIGNvCiAKIHZvaWQgTGF5ZXJSZW5kZXJlckNo cm9taXVtOjp1cGRhdGVBbmREcmF3Um9vdExheWVyKFRpbGVQYWludEludGVyZmFjZSYgdGlsZVBh aW50LCBUaWxlUGFpbnRJbnRlcmZhY2UmIHNjcm9sbGJhclBhaW50LCBjb25zdCBJbnRSZWN0JiB2 aXNpYmxlUmVjdCwgY29uc3QgSW50UmVjdCYgY29udGVudFJlY3QpCiB7Ci0gICAgLy8gTWFzayBv dXQgd3JpdGVzIHRvIGFscGhhIGNoYW5uZWw6IHN1YnBpeGVsIGFudGlhbGlhc2luZyB2aWEgU2tp YSByZXN1bHRzIGluIGludmFsaWQKLSAgICAvLyB6ZXJvIGFscGhhIHZhbHVlcyBvbiB0ZXh0IGds eXBocy4gVGhlIHJvb3QgbGF5ZXIgaXMgYWx3YXlzIG9wYXF1ZS4KLSAgICBHTEMobV9jb250ZXh0 LmdldCgpLCBtX2NvbnRleHQtPmNvbG9yTWFzayh0cnVlLCB0cnVlLCB0cnVlLCBmYWxzZSkpOwot CiAgICAgbV9yb290TGF5ZXJUaWxlci0+dXBkYXRlKHRpbGVQYWludCwgdmlzaWJsZVJlY3QpOwog ICAgIG1fcm9vdExheWVyVGlsZXItPmRyYXcodmlzaWJsZVJlY3QpOwogCkBAIC0yMjgsNiArMjI1 LDExIEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKGNvbnN0IEludFJl Y3QmIHZpc2libGVSZWN0LCBjb25zdCBJbnRSZWN0CiAgICAgLy8gYW5kIHZpZXdwb3J0LgogICAg IGludCB2aXNpYmxlUmVjdFdpZHRoID0gdmlzaWJsZVJlY3Qud2lkdGgoKTsKICAgICBpbnQgdmlz aWJsZVJlY3RIZWlnaHQgPSB2aXNpYmxlUmVjdC5oZWlnaHQoKTsKKworICAgIGlmICghbV9yb290 TGF5ZXItPm1fcmVuZGVyU3VyZmFjZSkKKyAgICAgICAgbV9yb290TGF5ZXItPmNyZWF0ZVJlbmRl clN1cmZhY2UoKTsKKyAgICBtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRS ZWN0ID0gSW50UmVjdCgwLCAwLCB2aXNpYmxlUmVjdFdpZHRoLCB2aXNpYmxlUmVjdEhlaWdodCk7 CisKICAgICBpZiAodmlzaWJsZVJlY3RXaWR0aCAhPSBtX3Jvb3RMYXllclRleHR1cmVXaWR0aCB8 fCB2aXNpYmxlUmVjdEhlaWdodCAhPSBtX3Jvb3RMYXllclRleHR1cmVIZWlnaHQpIHsKICAgICAg ICAgbV9yb290TGF5ZXJUZXh0dXJlV2lkdGggPSB2aXNpYmxlUmVjdFdpZHRoOwogICAgICAgICBt X3Jvb3RMYXllclRleHR1cmVIZWlnaHQgPSB2aXNpYmxlUmVjdEhlaWdodDsKQEAgLTI1MiwxNiAr MjU0LDE4IEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKGNvbnN0IElu dFJlY3QmIHZpc2libGVSZWN0LCBjb25zdCBJbnRSZWN0CiAKICAgICBtX3Njcm9sbFBvc2l0aW9u ID0gc2Nyb2xsUG9zaXRpb247CiAKKyAgICBBU1NFUlQobV9yb290TGF5ZXItPm1fcmVuZGVyU3Vy ZmFjZSk7CiAgICAgbV9kZWZhdWx0UmVuZGVyU3VyZmFjZSA9IG1fcm9vdExheWVyLT5tX3JlbmRl clN1cmZhY2UuZ2V0KCk7Ci0gICAgaWYgKCFtX2RlZmF1bHRSZW5kZXJTdXJmYWNlKQotICAgICAg ICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlID0gbV9yb290TGF5ZXItPmNyZWF0ZVJlbmRlclN1cmZh Y2UoKTsKLSAgICBtX2RlZmF1bHRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0ID0gSW50UmVj dCgwLCAwLCBtX3Jvb3RMYXllclRleHR1cmVXaWR0aCwgbV9yb290TGF5ZXJUZXh0dXJlSGVpZ2h0 KTsKIAogICAgIHVzZVJlbmRlclN1cmZhY2UobV9kZWZhdWx0UmVuZGVyU3VyZmFjZSk7CiAKICAg ICAvLyBDbGVhciB0byBibHVlIHRvIG1ha2UgaXQgZWFzaWVyIHRvIHNwb3QgdW5yZW5kZXJlZCBy ZWdpb25zLgogICAgIG1fY29udGV4dC0+Y2xlYXJDb2xvcigwLCAwLCAxLCAxKTsKKyAgICBtX2Nv bnRleHQtPmNvbG9yTWFzayh0cnVlLCB0cnVlLCB0cnVlLCB0cnVlKTsKICAgICBtX2NvbnRleHQt PmNsZWFyKEdyYXBoaWNzQ29udGV4dDNEOjpDT0xPUl9CVUZGRVJfQklUKTsKKyAgICAvLyBNYXNr IG91dCB3cml0ZXMgdG8gYWxwaGEgY2hhbm5lbDogc3VicGl4ZWwgYW50aWFsaWFzaW5nIHZpYSBT a2lhIHJlc3VsdHMgaW4gaW52YWxpZAorICAgIC8vIHplcm8gYWxwaGEgdmFsdWVzIG9uIHRleHQg Z2x5cGhzLiBUaGUgcm9vdCBsYXllciBpcyBhbHdheXMgb3BhcXVlLgorICAgIG1fY29udGV4dC0+ Y29sb3JNYXNrKHRydWUsIHRydWUsIHRydWUsIGZhbHNlKTsKIAogICAgIHVwZGF0ZUFuZERyYXdS b290TGF5ZXIodGlsZVBhaW50LCBzY3JvbGxiYXJQYWludCwgdmlzaWJsZVJlY3QsIGNvbnRlbnRS ZWN0KTsKIApAQCAtNjE1LDYgKzYxOSwyMyBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6 dXBkYXRlTGF5ZXJzUmVjdXJzaXZlKExheWVyQ2hyb21pdW0qIGxheWVyLCBjb25zdCBUcgogICAg ICAgICBzdGQ6OnN0YWJsZV9zb3J0KCZkZXNjZW5kYW50cy5hdCh0aGlzTGF5ZXJJbmRleCksIGRl c2NlbmRhbnRzLmVuZCgpLCBjb21wYXJlTGF5ZXJaKTsKIH0KIAordm9pZCBMYXllclJlbmRlcmVy Q2hyb21pdW06OnNldENvbXBvc2l0ZU9mZnNjcmVlbihib29sIGNvbXBvc2l0ZU9mZnNjcmVlbikK K3sKKyAgICBtX2NvbXBvc2l0ZU9mZnNjcmVlbiA9IGNvbXBvc2l0ZU9mZnNjcmVlbjsKKworICAg IGlmICghbV9yb290TGF5ZXIpIHsKKyAgICAgICAgbV9jb21wb3NpdGVPZmZzY3JlZW4gPSBmYWxz ZTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGlmIChtX2NvbXBvc2l0ZU9mZnNjcmVl bikgeworICAgICAgICAvLyBOZWVkIHRvIGV4cGxpY2l0bHkgc2V0IGEgTGF5ZXJSZW5kZXJlckNo cm9taXVtIGZvciB0aGUgbGF5ZXIgd2l0aCB0aGUgb2Zmc2NyZWVuIHRleHR1cmUsCisgICAgICAg IC8vIG9yIGVsc2UgdGhlIGNhbGwgdG8gcHJlcGFyZUNvbnRlbnRzVGV4dHVyZSgpIGluIHVzZVJl bmRlclN1cmZhY2UoKSB3aWxsIGZhaWwuCisgICAgICAgIG1fcm9vdExheWVyLT5zZXRMYXllclJl bmRlcmVyKHRoaXMpOworICAgIH0gZWxzZQorICAgICAgICBtX3Jvb3RMYXllci0+bV9yZW5kZXJT dXJmYWNlLmNsZWFyKCk7Cit9CisKIGJvb2wgTGF5ZXJSZW5kZXJlckNocm9taXVtOjp1c2VSZW5k ZXJTdXJmYWNlKFJlbmRlclN1cmZhY2VDaHJvbWl1bSogcmVuZGVyU3VyZmFjZSkKIHsKICAgICBp ZiAobV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9PSByZW5kZXJTdXJmYWNlKQpAQCAtNjIyLDcgKzY0 Myw3IEBAIGJvb2wgTGF5ZXJSZW5kZXJlckNocm9taXVtOjp1c2VSZW5kZXJTdXJmYWNlKFJlbmRl clN1cmZhY2VDaHJvbWl1bSogcmVuZGVyU3VyZmFjCiAKICAgICBtX2N1cnJlbnRSZW5kZXJTdXJm YWNlID0gcmVuZGVyU3VyZmFjZTsKIAotICAgIGlmIChyZW5kZXJTdXJmYWNlID09IG1fZGVmYXVs dFJlbmRlclN1cmZhY2UpIHsKKyAgICBpZiAocmVuZGVyU3VyZmFjZSA9PSBtX2RlZmF1bHRSZW5k ZXJTdXJmYWNlICYmICFtX2NvbXBvc2l0ZU9mZnNjcmVlbikgewogICAgICAgICBHTEMobV9jb250 ZXh0LmdldCgpLCBtX2NvbnRleHQtPmJpbmRGcmFtZWJ1ZmZlcihHcmFwaGljc0NvbnRleHQzRDo6 RlJBTUVCVUZGRVIsIDApKTsKICAgICAgICAgc2V0RHJhd1ZpZXdwb3J0UmVjdChyZW5kZXJTdXJm YWNlLT5tX2NvbnRlbnRSZWN0LCB0cnVlKTsKICAgICAgICAgcmV0dXJuIHRydWU7CkBAIC02OTAs OCArNzExLDkgQEAgdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnNldFNjaXNzb3JUb1JlY3Qo Y29uc3QgSW50UmVjdCYgc2Npc3NvclJlY3QpCiAgICAgaW50IHNjaXNzb3JYID0gc2Npc3NvclJl Y3QueCgpIC0gbV9jdXJyZW50UmVuZGVyU3VyZmFjZS0+bV9jb250ZW50UmVjdC54KCk7CiAgICAg Ly8gV2hlbiByZW5kZXJpbmcgdG8gdGhlIGRlZmF1bHQgcmVuZGVyIHN1cmZhY2Ugd2UncmUgcmVu ZGVyaW5nIHVwc2lkZSBkb3duIHNvIHRoZSB0b3AKICAgICAvLyBvZiB0aGUgR0wgc2Npc3NvciBp cyB0aGUgYm90dG9tIG9mIG91ciBsYXllci4KKyAgICAvLyBCdXQsIGlmIHJlbmRlcmluZyB0byBv ZmZzY3JlZW4gdGV4dHVyZSwgd2UgcmV2ZXJzZSBvdXIgc2Vuc2Ugb2YgJ3Vwc2lkZSBkb3duJy4K ICAgICBpbnQgc2Npc3Nvclk7Ci0gICAgaWYgKG1fY3VycmVudFJlbmRlclN1cmZhY2UgPT0gbV9k ZWZhdWx0UmVuZGVyU3VyZmFjZSkKKyAgICBpZiAobV9jdXJyZW50UmVuZGVyU3VyZmFjZSA9PSBt X2RlZmF1bHRSZW5kZXJTdXJmYWNlICYmICFtX2NvbXBvc2l0ZU9mZnNjcmVlbikKICAgICAgICAg c2Npc3NvclkgPSBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LmhlaWdodCgp IC0gKHNjaXNzb3JSZWN0LmJvdHRvbSgpIC0gbV9jdXJyZW50UmVuZGVyU3VyZmFjZS0+bV9jb250 ZW50UmVjdC55KCkpOwogICAgIGVsc2UKICAgICAgICAgc2Npc3NvclkgPSBzY2lzc29yUmVjdC55 KCkgLSBtX2N1cnJlbnRSZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRSZWN0LnkoKTsKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9t aXVtLmggYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5oCmluZGV4IDY0NzQyNjlkZmMyNThhNTUwYTNkNGU2NTk2YjdjN2VmMzkwNjM0NDAu LjNkM2U3ODRjNGNhMTg1ZDkzY2YzYThlMTg2ZTFhMDQzZTc4NmY2M2YgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgK KysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hy b21pdW0uaApAQCAtODcsNiArODcsMTAgQEAgcHVibGljOgogCiAgICAgYm9vbCBoYXJkd2FyZUNv bXBvc2l0aW5nKCkgY29uc3QgeyByZXR1cm4gbV9oYXJkd2FyZUNvbXBvc2l0aW5nOyB9CiAKKyAg ICB2b2lkIHNldENvbXBvc2l0ZU9mZnNjcmVlbihib29sKTsKKyAgICBib29sIGlzQ29tcG9zaXRp bmdPZmZzY3JlZW4oKSB7IHJldHVybiBtX2NvbXBvc2l0ZU9mZnNjcmVlbjsgfQorICAgIExheWVy VGV4dHVyZSogZ2V0T2Zmc2NyZWVuTGF5ZXJUZXh0dXJlKCkgeyByZXR1cm4gbV9jb21wb3NpdGVP ZmZzY3JlZW4gPyBtX3Jvb3RMYXllci0+bV9yZW5kZXJTdXJmYWNlLT5tX2NvbnRlbnRzVGV4dHVy ZS5nZXQoKSA6IDA7IH0KKwogICAgIHZvaWQgc2V0Um9vdExheWVyQ2FudmFzU2l6ZShjb25zdCBJ bnRTaXplJik7CiAKICAgICBHcmFwaGljc0NvbnRleHQqIHJvb3RMYXllckdyYXBoaWNzQ29udGV4 dCgpIGNvbnN0IHsgcmV0dXJuIG1fcm9vdExheWVyR3JhcGhpY3NDb250ZXh0LmdldCgpOyB9CkBA IC0xNjAsNiArMTY0LDcgQEAgcHJpdmF0ZToKICAgICBSZW5kZXJTdXJmYWNlQ2hyb21pdW0qIG1f Y3VycmVudFJlbmRlclN1cmZhY2U7CiAKICAgICB1bnNpZ25lZCBtX29mZnNjcmVlbkZyYW1lYnVm ZmVySWQ7CisgICAgYm9vbCBtX2NvbXBvc2l0ZU9mZnNjcmVlbjsKIAogI2lmIFBMQVRGT1JNKFNL SUEpCiAgICAgT3duUHRyPHNraWE6OlBsYXRmb3JtQ2FudmFzPiBtX3Jvb3RMYXllckNhbnZhczsK