57768 2011-04-04 11:25:23 -0700 Accelerated Canvas2D path failing when constructing large canvases. 2011-04-08 16:01:59 -0700 1 1 1 Unclassified WebKit Canvas 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 0 twiz webkit-unassigned commit-queue jamesr kbr mdelaney7 senorblanco zmo oldest_to_newest 378901 0 twiz 2011-04-04 11:25:23 -0700 The Chromium accelerated canvas 2d path fails when the requested canvas size is larger than supported by the GL implementation. The code fails to allocate a texture, yet continues to try to use the accelerated path. This is demonstrated by test: fast/canvas/canvas-large-dimensions.html This issue is related to: https://bugs.webkit.org/show_bug.cgi?id=52341 https://bugs.webkit.org/show_bug.cgi?id=52391 378985 1 88105 twiz 2011-04-04 12:55:43 -0700 Created attachment 88105 Patch 378987 2 88105 twiz 2011-04-04 12:57:58 -0700 Comment on attachment 88105 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=88105&action=review > Source/WebCore/ChangeLog:-424 > - DumpRenderTreeÕs delegate to be dispatched. The delegate doesnÕt expect to be called between Will upload a new version without these edits. My editor must have had trouble with the symbols . . . 379024 3 88115 twiz 2011-04-04 13:37:22 -0700 Created attachment 88115 Patch 379029 4 88115 jamesr 2011-04-04 13:44:54 -0700 Comment on attachment 88115 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=88115&action=review > Source/WebCore/platform/graphics/gpu/DrawingBuffer.h:69 > + bool isValid() const { return m_context; } > + IMO instead of having an isValid() DrawingBuffer::create() should return NULL if the drawing buffer couldn't be constructed, and reset() should return false if it can't resize to the new bounds. > Source/WebKit/chromium/src/GraphicsContext3DChromium.cpp:621 > bool GraphicsContext3DInternal::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels) > { > + if (width > m_maxTextureSize || height > m_maxTextureSize) { > + synthesizeGLError(GraphicsContext3D::INVALID_VALUE); > + return false; > + } It seems weird to short-circuit the normal error handling, but only for this function and only for chromium. What do you think, Ken? This check is wrong if level != 0, I believe. 379035 5 88115 kbr 2011-04-04 13:53:31 -0700 Comment on attachment 88115 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=88115&action=review >> Source/WebKit/chromium/src/GraphicsContext3DChromium.cpp:621 >> + } > > It seems weird to short-circuit the normal error handling, but only for this function and only for chromium. What do you think, Ken? > > This check is wrong if level != 0, I believe. The problem is that the calling code relies on this texImage2D call to return false if something went wrong, and it would be far too expensive to call glGetError after each texImage2D call. This explicit shortcut is a concession to make large layers work properly. Alternatively, we could do some queries at the call site (which is rarely called) to see whether the texture was allocated correctly. It's a problem that glGetTexLevelParameteriv isn't available in GLES2, but maybe there's another query that could be made to see if the texture object was successfully allocated. 379041 6 88115 twiz 2011-04-04 13:55:58 -0700 Comment on attachment 88115 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=88115&action=review >> Source/WebCore/platform/graphics/gpu/DrawingBuffer.h:69 >> + > > IMO instead of having an isValid() DrawingBuffer::create() should return NULL if the drawing buffer couldn't be constructed, and reset() should return false if it can't resize to the new bounds. Will upload a new patch with your suggested changes. >> Source/WebKit/chromium/src/GraphicsContext3DChromium.cpp:621 >> + } > > It seems weird to short-circuit the normal error handling, but only for this function and only for chromium. What do you think, Ken? > > This check is wrong if level != 0, I believe. You're right that it's a little different to add the error handling here. I wanted the routine to respect the comments in GraphicsContext3DInternal.h (http://www.google.com/codesearch/p?vert=chromium#OAMlx_jo-ck/src/third_party/WebKit/Source/WebKit/chromium/src/GraphicsContext3DInternal.h&l=190) I believe it should work for levels other than 0. 379045 7 jamesr 2011-04-04 13:57:20 -0700 (In reply to comment #5) > (From update of attachment 88115 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=88115&action=review > > >> Source/WebKit/chromium/src/GraphicsContext3DChromium.cpp:621 > >> + } > > > > It seems weird to short-circuit the normal error handling, but only for this function and only for chromium. What do you think, Ken? > > > > This check is wrong if level != 0, I believe. > > The problem is that the calling code relies on this texImage2D call to return false if something went wrong, and it would be far too expensive to call glGetError after each texImage2D call. This explicit shortcut is a concession to make large layers work properly. Alternatively, we could do some queries at the call site (which is rarely called) to see whether the texture was allocated correctly. It's a problem that glGetTexLevelParameteriv isn't available in GLES2, but maybe there's another query that could be made to see if the texture object was successfully allocated. Can we just make the caller (DrawingBuffer stuff here) glGet() the texture bounds and check that itself? If the texture object creation fails for any other reason then this check won't do anything. We query and cache the max texture bounds in some places currently, IIRC 379059 8 88115 senorblanco 2011-04-04 14:06:06 -0700 Comment on attachment 88115 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=88115&action=review >>>>> Source/WebKit/chromium/src/GraphicsContext3DChromium.cpp:621 >>>>> + } >>>> >>>> It seems weird to short-circuit the normal error handling, but only for this function and only for chromium. What do you think, Ken? >>>> >>>> This check is wrong if level != 0, I believe. >>> >>> The problem is that the calling code relies on this texImage2D call to return false if something went wrong, and it would be far too expensive to call glGetError after each texImage2D call. This explicit shortcut is a concession to make large layers work properly. Alternatively, we could do some queries at the call site (which is rarely called) to see whether the texture was allocated correctly. It's a problem that glGetTexLevelParameteriv isn't available in GLES2, but maybe there's another query that could be made to see if the texture object was successfully allocated. >> >> You're right that it's a little different to add the error handling here. I wanted the routine to respect the comments in GraphicsContext3DInternal.h (http://www.google.com/codesearch/p?vert=chromium#OAMlx_jo-ck/src/third_party/WebKit/Source/WebKit/chromium/src/GraphicsContext3DInternal.h&l=190) >> >> I believe it should work for levels other than 0. > > Can we just make the caller (DrawingBuffer stuff here) glGet() the texture bounds and check that itself? If the texture object creation fails for any other reason then this check won't do anything. > > We query and cache the max texture bounds in some places currently, IIRC KBR: I'm not too worried about a call to getIntegerv(), given that GraphicsContext3D::texImage2DResourceSafe() further up the stack is doing an enormous malloc() and memset() on every texture allocation (we should really doing a glClear() on the bound FBO instead, but that's another bug). I agree with jamesr: putting the check in DrawingBuffer would fix the bug, and skip both the malloc() and memset() for large layers. (BTW, we already do such a check via getIntegerv on every texture creation in platform/graphics/Texture.cpp.) 379063 9 jamesr 2011-04-04 14:10:38 -0700 Texture::create() probably should be calling getIntegerv() once and caching the result. Whoops! 379065 10 kbr 2011-04-04 14:14:19 -0700 (In reply to comment #8) > KBR: I'm not too worried about a call to getIntegerv(), given that GraphicsContext3D::texImage2DResourceSafe() further up the stack is doing an enormous malloc() and memset() on every texture allocation (we should really doing a glClear() on the bound FBO instead, but that's another bug). I agree with jamesr: putting the check in DrawingBuffer would fix the bug, and skip both the malloc() and memset() for large layers. (BTW, we already do such a check via getIntegerv on every texture creation in platform/graphics/Texture.cpp.) I agree that fixing this with a similar check at the call site would be good. It doesn't guarantee that the underlying texImage2D call will succeed, though. The safest thing to do would be to query the width and height of the resulting texture after the call, but we can't do that with the current GraphicsContext3D API, which is targeted at GLES 2.0. For the time being I think it would be fine to make the calling code behave similarly to Texture.cpp. 381452 11 88657 twiz 2011-04-07 10:17:47 -0700 Created attachment 88657 Patch 381480 12 88657 twiz 2011-04-07 10:46:16 -0700 Comment on attachment 88657 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? 381698 13 kbr 2011-04-07 14:20:56 -0700 (In reply to comment #12) > (From update of attachment 88657 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? I've looked back through the command buffer client code and am 99% sure that it will work. You'd need to test to be sure. 381704 14 zmo 2011-04-07 14:27:28 -0700 (In reply to comment #12) > (From update of attachment 88657 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? This will break the tests running with in-process gl. 381708 15 zmo 2011-04-07 14:29:36 -0700 (In reply to comment #12) > (From update of attachment 88657 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? Also, it would be more efficient to call texImage2DResourceSafeNoClear because if you pass texImage2D with NULL data to command buffer, it will definitely do the resource safe thing and clear. 381712 16 senorblanco 2011-04-07 14:32:16 -0700 (In reply to comment #14) > (In reply to comment #12) > > (From update of attachment 88657 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > This will break the tests running with in-process gl. I think the reason they broke before is that I was relying on the clearing behaviour that used to exist in both the command buffer and the in-process impl. If we instead put in an explicit glClear() on the first bind of the DrawingBuffer, I think they should pass.(In reply to comment #15) > (In reply to comment #12) > > (From update of attachment 88657 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > Also, it would be more efficient to call texImage2DResourceSafeNoClear because if you pass texImage2D with NULL data to command buffer, it will definitely do the resource safe thing and clear. Really? Can we change this behaviour? Canvas does not need resource safety, and this is a big overhead when resizing the window: the malloc(), the memset() and the texture upload are not necessary, since we know we're going to do a glClear() right away anyway. 381713 17 senorblanco 2011-04-07 14:34:45 -0700 (In reply to comment #14) > (In reply to comment #12) > > (From update of attachment 88657 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > This will break the tests running with in-process gl. I think the reason they failed before was that I was relying on the FBO textures being cleared automatically in the in-process version (in the same way they were in the command buffers). If we call glClear() the first time the DrawingBuffer is bound, these tests should pass. 381716 18 kbr 2011-04-07 14:35:14 -0700 (In reply to comment #16) > (In reply to comment #14) > > (In reply to comment #12) > > > (From update of attachment 88657 [details] [details] [details]) > > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > > > This will break the tests running with in-process gl. > > I think the reason they broke before is that I was relying on the clearing behaviour that used to exist in both the command buffer and the in-process impl. If we instead put in an explicit glClear() on the first bind of the DrawingBuffer, I think they should pass.(In reply to comment #15) > > (In reply to comment #12) > > > (From update of attachment 88657 [details] [details] [details]) > > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > > > Also, it would be more efficient to call texImage2DResourceSafeNoClear because if you pass texImage2D with NULL data to command buffer, it will definitely do the resource safe thing and clear. > > Really? Can we change this behaviour? Canvas does not need resource safety, and this is a big overhead when resizing the window: the malloc(), the memset() and the texture upload are not necessary, since we know we're going to do a glClear() right away anyway. One point. Even without disabling the resource safety of the command buffer, passing NULL should be more efficient than passing down a zeroed array, because the allocation of the temporary zeroed buffer will occur entirely on the service side, rather than being passed across shared memory in the transfer buffer. 381743 19 zmo 2011-04-07 14:54:09 -0700 (In reply to comment #17) > (In reply to comment #14) > > (In reply to comment #12) > > > (From update of attachment 88657 [details] [details] [details]) > > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > > > This will break the tests running with in-process gl. > > I think the reason they failed before was that I was relying on the FBO textures being cleared automatically in the in-process version (in the same way they were in the command buffers). > > If we call glClear() the first time the DrawingBuffer is bound, these tests should pass. Also, in the in-process gl, we emit an INVALID_VALUE if passed in data is NULL. You have to remove that before calling texImage2D with NULL. 381746 20 zmo 2011-04-07 14:56:05 -0700 (In reply to comment #16) > (In reply to comment #14) > > (In reply to comment #12) > > > (From update of attachment 88657 [details] [details] [details]) > > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > > > This will break the tests running with in-process gl. > > I think the reason they broke before is that I was relying on the clearing behaviour that used to exist in both the command buffer and the in-process impl. If we instead put in an explicit glClear() on the first bind of the DrawingBuffer, I think they should pass.(In reply to comment #15) > > (In reply to comment #12) > > > (From update of attachment 88657 [details] [details] [details]) > > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > > > Also, it would be more efficient to call texImage2DResourceSafeNoClear because if you pass texImage2D with NULL data to command buffer, it will definitely do the resource safe thing and clear. > > Really? Can we change this behaviour? Canvas does not need resource safety, and this is a big overhead when resizing the window: the malloc(), the memset() and the texture upload are not necessary, since we know we're going to do a glClear() right away anyway. I don't think we should change the general texImage2D behavior. However, you could add a new command in the command buffer like texImage2DLightWeight or something. 381748 21 kbr 2011-04-07 14:58:14 -0700 (In reply to comment #19) > (In reply to comment #17) > > (In reply to comment #14) > > > (In reply to comment #12) > > > > (From update of attachment 88657 [details] [details] [details] [details]) > > > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > > > > > This will break the tests running with in-process gl. > > > > I think the reason they failed before was that I was relying on the FBO textures being cleared automatically in the in-process version (in the same way they were in the command buffers). > > > > If we call glClear() the first time the DrawingBuffer is bound, these tests should pass. > > Also, in the in-process gl, we emit an INVALID_VALUE if passed in data is NULL. You have to remove that before calling texImage2D with NULL. Mo's right; I forgot about that check in webgraphicscontext3d_in_process_impl.cc in the Chromium tree. I talked with senorblanco about this topic earlier, and suggested we could have another argument to GraphicsContext3D::create which would indicate whether the caller is trusted (compositor, canvas2d) or untrusted (webgl). In the former case we could disable some of these checks. twiz, i'm not sure what would be the fastest path forward for you, but feel free to make whatever changes you need to in order to make this most efficient, including adding new entry points. I do think that the constructor idea might be the best long-term direction, though. 381759 22 zmo 2011-04-07 15:04:41 -0700 (In reply to comment #21) > (In reply to comment #19) > > (In reply to comment #17) > > > (In reply to comment #14) > > > > (In reply to comment #12) > > > > > (From update of attachment 88657 [details] [details] [details] [details] [details]) > > > > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > > > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > > > > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > > > > > > > This will break the tests running with in-process gl. > > > > > > I think the reason they failed before was that I was relying on the FBO textures being cleared automatically in the in-process version (in the same way they were in the command buffers). > > > > > > If we call glClear() the first time the DrawingBuffer is bound, these tests should pass. > > > > Also, in the in-process gl, we emit an INVALID_VALUE if passed in data is NULL. You have to remove that before calling texImage2D with NULL. > > Mo's right; I forgot about that check in webgraphicscontext3d_in_process_impl.cc in the Chromium tree. > > I talked with senorblanco about this topic earlier, and suggested we could have another argument to GraphicsContext3D::create which would indicate whether the caller is trusted (compositor, canvas2d) or untrusted (webgl). In the former case we could disable some of these checks. We could have a light-weight command buffer where all the sanity checking and other stuff are behind the DEBUG flag, and it simply passes commands down to underlying drivers. > > twiz, i'm not sure what would be the fastest path forward for you, but feel free to make whatever changes you need to in order to make this most efficient, including adding new entry points. I do think that the constructor idea might be the best long-term direction, though. 381766 23 senorblanco 2011-04-07 15:10:50 -0700 (In reply to comment #21) > (In reply to comment #19) > > (In reply to comment #17) > > > (In reply to comment #14) > > > > (In reply to comment #12) > > > > > (From update of attachment 88657 [details] [details] [details] [details] [details]) > > > > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > > > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > > > > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > > > > > > > This will break the tests running with in-process gl. > > > > > > I think the reason they failed before was that I was relying on the FBO textures being cleared automatically in the in-process version (in the same way they were in the command buffers). > > > > > > If we call glClear() the first time the DrawingBuffer is bound, these tests should pass. > > > > Also, in the in-process gl, we emit an INVALID_VALUE if passed in data is NULL. You have to remove that before calling texImage2D with NULL. > > Mo's right; I forgot about that check in webgraphicscontext3d_in_process_impl.cc in the Chromium tree. Aha, that's what I ran into before (just forgot where it was). > I talked with senorblanco about this topic earlier, and suggested we could have another argument to GraphicsContext3D::create which would indicate whether the caller is trusted (compositor, canvas2d) or untrusted (webgl). In the former case we could disable some of these checks. > > twiz, i'm not sure what would be the fastest path forward for you, but feel free to make whatever changes you need to in order to make this most efficient, including adding new entry points. I do think that the constructor idea might be the best long-term direction, though. I think the constructor param is a good idea. Since this would require chrome-side changes (as would the in-process change above), perhaps we should split the work into just fixing the layout test, and address the performance issues in a subsequent patch (after the chrome changes). My preference would be to land something between revs 2 and 3 of this patch (including the DrawingBuffer::create returning NULL change that jamesr suggested, but excluding the ResourceSafeNoClear changes). This would fix the layout test, and we can look at improving the performance once the chrome-side changes have landed. Does that sound good? 381778 24 twiz 2011-04-07 15:25:40 -0700 (In reply to comment #23) > (In reply to comment #21) > > (In reply to comment #19) > > > (In reply to comment #17) > > > > (In reply to comment #14) > > > > > (In reply to comment #12) > > > > > > (From update of attachment 88657 [details] [details] [details] [details] [details] [details]) > > > > > > View in context: https://bugs.webkit.org/attachment.cgi?id=88657&action=review > > > > > > > > > > > > > Source/WebCore/platform/graphics/gpu/DrawingBuffer.cpp:205 > > > > > > > + m_context->texImage2DResourceSafeNoClear(GraphicsContext3D::TEXTURE_2D, 0, internalColorFormat, m_size.width(), m_size.height(), 0, colorFormat, GraphicsContext3D::UNSIGNED_BYTE); > > > > > > > > > > > > I would like to change this call to a simple texImage2D with a NULL data parameter. Can someone please confirm if this will work? > > > > > > > > > > This will break the tests running with in-process gl. > > > > > > > > I think the reason they failed before was that I was relying on the FBO textures being cleared automatically in the in-process version (in the same way they were in the command buffers). > > > > > > > > If we call glClear() the first time the DrawingBuffer is bound, these tests should pass. > > > > > > Also, in the in-process gl, we emit an INVALID_VALUE if passed in data is NULL. You have to remove that before calling texImage2D with NULL. > > > > Mo's right; I forgot about that check in webgraphicscontext3d_in_process_impl.cc in the Chromium tree. > > Aha, that's what I ran into before (just forgot where it was). > > > I talked with senorblanco about this topic earlier, and suggested we could have another argument to GraphicsContext3D::create which would indicate whether the caller is trusted (compositor, canvas2d) or untrusted (webgl). In the former case we could disable some of these checks. > > > > twiz, i'm not sure what would be the fastest path forward for you, but feel free to make whatever changes you need to in order to make this most efficient, including adding new entry points. I do think that the constructor idea might be the best long-term direction, though. > > I think the constructor param is a good idea. Since this would require chrome-side changes (as would the in-process change above), perhaps we should split the work into just fixing the layout test, and address the performance issues in a subsequent patch (after the chrome changes). > > My preference would be to land something between revs 2 and 3 of this patch (including the DrawingBuffer::create returning NULL change that jamesr suggested, but excluding the ResourceSafeNoClear changes). This would fix the layout test, and we can look at improving the performance once the chrome-side changes have landed. > > Does that sound good? Yes, that sounds very good. I was hoping it would be an easy change to remove the heavy initialization code, but after all of this discussion, it is obvious that it is a separate issue to address. 382386 25 88842 twiz 2011-04-08 10:56:59 -0700 Created attachment 88842 Patch 382389 26 twiz 2011-04-08 10:58:12 -0700 Hopefully the last revision. This final patch only corrects the resizing behaviour, but does not address the performance of the texture construction. 382446 27 88842 kbr 2011-04-08 12:11:23 -0700 Comment on attachment 88842 Patch Looks good. 382628 28 88842 commit-queue 2011-04-08 16:01:52 -0700 Comment on attachment 88842 Patch Clearing flags on attachment: 88842 Committed r83355: <http://trac.webkit.org/changeset/83355> 382629 29 commit-queue 2011-04-08 16:01:59 -0700 All reviewed patches have been landed. Closing bug. 88105 2011-04-04 12:55:43 -0700 2011-04-04 13:37:17 -0700 Patch bug-57768-20110404155332.patch text/plain 12813 twiz SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDgyODUyKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjUgQEAKKzIwMTEtMDQtMDEgIEplZmYgVGlt YW51cyAgPHR3aXpAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIFN5bnRoZXNpemUgYSBHTCBlcnJvciB3aGVuIHJlcXVlc3Rpbmcg YSB0ZXh0dXJlIHRoYXQgaXMgbGFyZ2VyIHRoYW4gdGhlCisgICAgICAgIHN1cHBvcnRlZCBtYXhp bXVtIGRpbWVuc2lvbnMgb2YgdGhlIGhvc3RpbmcgR0wgaW1wbGVtZW50YXRpb24uCisgICAgICAg IEFsc28sIGVuc3VyZSB0aGF0IHRoZSBhY2NlbGVyYXRlZCBjYW52YXMgcGF0aCBuZXZlciB1c2Vz IGFuIGludmFsaWQKKyAgICAgICAgRHJhd2luZ0J1ZmZlci4KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU3NzY4CisKKyAgICAgICAgVGVzdHM6IGZhc3Qv Y2FudmFzL2NhbnZhcy1sYXJnZS1kaW1lbnNpb25zLmh0bWwKKworICAgICAgICAqIGh0bWwvY2Fu dmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDYW52 YXNSZW5kZXJpbmdDb250ZXh0MkQ6OkNhbnZhc1JlbmRlcmluZ0NvbnRleHQyRCk6CisgICAgICAg IChXZWJDb3JlOjpDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQ6OnJlc2V0KToKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9EcmF3aW5nQnVmZmVyQ2hyb21pdW0uY3BwOgorICAg ICAgICAoV2ViQ29yZTo6Z2VuZXJhdGVDb2xvclRleHR1cmUpOgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2dwdS9EcmF3aW5nQnVmZmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRyYXdp bmdCdWZmZXI6OnJlc2V0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2lu Z0J1ZmZlci5oOgorICAgICAgICAoV2ViQ29yZTo6RHJhd2luZ0J1ZmZlcjo6aXNWYWxpZCk6CisK IDIwMTEtMDQtMDQgIE1hbGNvbG0gTWFjTGVvZCAgPG1tYWNsZW9kQHdlYm1haWwuY28uemE+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgS2V2aW4gT2xsaXZpZXIuCkBAIC00MjEsMTEgKzQ0MywxMSBA QAogCiAgICAgICAgIFRoZSBjcmFzaCBoYXBwZW5zIGJlY2F1c2UgcmVzZXR0aW5nIHRoZSBwYWdl IHNjYWxlIGFzIHBhcnQgb2YgcHJlcGFyaW5nIHRoZSBXZWJWaWV3IGZvciB0aGUKICAgICAgICAg bmV4dCB0ZXN0IHRyaWdnZXJlZCBsYXlvdXQsIHdoaWNoIGluIHR1cm4gY2F1c2VkIGEgcGx1Zy1p biB0byBtYWtlIGEgcmVzb3VyY2UgcmVxdWVzdCwgYW5kCi0gICAgICAgIER1bXBSZW5kZXJUcmVl 1XMgZGVsZWdhdGUgdG8gYmUgZGlzcGF0Y2hlZC4gVGhlIGRlbGVnYXRlIGRvZXNu1XQgZXhwZWN0 IHRvIGJlIGNhbGxlZCBiZXR3ZWVuCisgICAgICAgIER1bXBSZW5kZXJUcmVlcyBkZWxlZ2F0ZSB0 byBiZSBkaXNwYXRjaGVkLiBUaGUgZGVsZWdhdGUgZG9lc27vv710IGV4cGVjdCB0byBiZSBjYWxs ZWQgYmV0d2VlbgogICAgICAgICB0ZXN0cywgYW5kIGl0IHJlZmVyZW5jZXMgdGhlIGxheW91dCB0 ZXN0IGNvbnRyb2xsZXIsIHdoaWNoIGlzIG51bGwuCiAKICAgICAgICAgKiBwYWdlL0ZyYW1lLmNw cDoKLSAgICAgICAgKFdlYkNvcmU6OkZyYW1lOjpzY2FsZVBhZ2UpOiBBdm9pZCBhbiB1bm5lY2Vz c2FyeSBsYXlvdXQgaWYgdGhlIHBhZ2Ugc2NhbGUgaXNu1XQgY2hhbmdpbmcuIFRoaXMKKyAgICAg ICAgKFdlYkNvcmU6OkZyYW1lOjpzY2FsZVBhZ2UpOiBBdm9pZCBhbiB1bm5lY2Vzc2FyeSBsYXlv dXQgaWYgdGhlIHBhZ2Ugc2NhbGUgaXNu77+9dCBjaGFuZ2luZy4gVGhpcwogICAgICAgICBpcyBt b3JlIGVmZmljaWVudCwgYW5kIGhhcyB0aGUgc2lkZSBlZmZlY3Qgb2YgYXZvaWRpbmcgdGhlIGNy YXNoIGluIER1bXBSZW5kZXJUcmVlLCBhbHRob3VnaAogICAgICAgICBEdW1wUmVuZGVyVHJlZSBj b3VsZCBzdGlsbCBjcmFzaCB3aGVuIGFmdGVyIGEgdGVzdCB3aXRoIGRpc2FibGVkIHBsdWctaW5z IGFuZCBhIG5vbi0xIHBhZ2Ugc2NhbGUuCiAgICAgICAgIEkgdGhpbmsgdGhlcmUgYXJlIGN1cnJl bnRseSBubyBzdWNoIHRlc3RzLCBzbyBJIGFtIG5vdCBmaXhpbmcgRHVtcFJlbmRlclRyZWUuCkBA IC00MjIwLDcgKzQyNDIsNyBAQAogICAgICAgICAqIGRvbS9EYXRhc2V0RE9NU3RyaW5nTWFwLmNw cDoKICAgICAgICAgKFdlYkNvcmU6OnByb3BlcnR5TmFtZU1hdGNoZXNBdHRyaWJ1dGVOYW1lKToK IAotMjAxMS0wMy0yOSAgQ3NhYmEgT3N6dHJvZ29uw6FjICA8b3NzeUB3ZWJraXQub3JnPgorMjAx MS0wMy0yOSAgQ3NhYmEgT3N6dHJvZ29u77+9w6FjICA8b3NzeUB3ZWJraXQub3JnPgogCiAgICAg ICAgIFVucmV2aWV3ZWQgcm9sbG91dCByODIyODIsIHBhcnQgb2YgcjgyMjg4LCByODIyOTguCiAK QEAgLTM1NzA5LDQgKzM1NzMxLDQgQEAgcmV2aXNpb24uCiAgICAgICAgICogYmluZGluZ3Mvdjgv Y3VzdG9tL1Y4RGF0YVZpZXdDdXN0b20uY3BwOgogICAgICAgICAoV2ViQ29yZTo6VjhEYXRhVmll dzo6Y29uc3RydWN0b3JDYWxsYmFjayk6CiAKLT09IFJvbGxlZCBvdmVyIHRvIENoYW5nZUxvZy0y MDExLTAyLTE2ID09Cis9PSBSb2xsZWQgb3ZlciB0byBDaGFuZ2VMb2ctMjAxMS0wMi0xNiA9PQpc IE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvY2Fu dmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dl YkNvcmUvaHRtbC9jYW52YXMvQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJELmNwcAkocmV2aXNpb24g ODI3MDYpCisrKyBTb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9DYW52YXNSZW5kZXJpbmdDb250 ZXh0MkQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMzMsNyArMTMzLDEyIEBAIENhbnZhc1JlbmRl cmluZ0NvbnRleHQyRDo6Q2FudmFzUmVuZGVyaW4KICAgICAgICAgbV9jb250ZXh0M0QgPSBwLT5z aGFyZWRHcmFwaGljc0NvbnRleHQzRCgpOwogICAgICAgICBpZiAobV9jb250ZXh0M0QpIHsKICAg ICAgICAgICAgIG1fZHJhd2luZ0J1ZmZlciA9IG1fY29udGV4dDNELT5ncmFwaGljc0NvbnRleHQz RCgpLT5jcmVhdGVEcmF3aW5nQnVmZmVyKEludFNpemUoY2FudmFzLT53aWR0aCgpLCBjYW52YXMt PmhlaWdodCgpKSk7Ci0gICAgICAgICAgICBjLT5zZXRTaGFyZWRHcmFwaGljc0NvbnRleHQzRCht X2NvbnRleHQzRC5nZXQoKSwgbV9kcmF3aW5nQnVmZmVyLmdldCgpLCBJbnRTaXplKGNhbnZhcy0+ d2lkdGgoKSwgY2FudmFzLT5oZWlnaHQoKSkpOworICAgICAgICAgICAgaWYgKCFtX2RyYXdpbmdC dWZmZXItPmlzVmFsaWQoKSkgeworICAgICAgICAgICAgICAgIGMtPnNldFNoYXJlZEdyYXBoaWNz Q29udGV4dDNEKDAsIDAsIEludFNpemUoKSk7CisgICAgICAgICAgICAgICAgbV9kcmF3aW5nQnVm ZmVyLmNsZWFyKCk7CisgICAgICAgICAgICAgICAgbV9jb250ZXh0M0QuY2xlYXIoKTsKKyAgICAg ICAgICAgIH0gZWxzZQorICAgICAgICAgICAgICAgIGMtPnNldFNoYXJlZEdyYXBoaWNzQ29udGV4 dDNEKG1fY29udGV4dDNELmdldCgpLCBtX2RyYXdpbmdCdWZmZXIuZ2V0KCksIEludFNpemUoY2Fu dmFzLT53aWR0aCgpLCBjYW52YXMtPmhlaWdodCgpKSk7CiAgICAgICAgIH0KICAgICB9CiAjZW5k aWYKQEAgLTE3MywxMiArMTc4LDE4IEBAIHZvaWQgQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJEOjpy ZXNldCgpCiAgICAgaWYgKEdyYXBoaWNzQ29udGV4dCogYyA9IGRyYXdpbmdDb250ZXh0KCkpIHsK ICAgICAgICAgaWYgKG1fY29udGV4dDNEICYmIG1fZHJhd2luZ0J1ZmZlcikgewogICAgICAgICAg ICAgbV9kcmF3aW5nQnVmZmVyLT5yZXNldChJbnRTaXplKGNhbnZhcygpLT53aWR0aCgpLCBjYW52 YXMoKS0+aGVpZ2h0KCkpKTsKLSAgICAgICAgICAgIGMtPnNldFNoYXJlZEdyYXBoaWNzQ29udGV4 dDNEKG1fY29udGV4dDNELmdldCgpLCBtX2RyYXdpbmdCdWZmZXIuZ2V0KCksIEludFNpemUoY2Fu dmFzKCktPndpZHRoKCksIGNhbnZhcygpLT5oZWlnaHQoKSkpOworICAgICAgICAgICAgaWYgKG1f ZHJhd2luZ0J1ZmZlci0+aXNWYWxpZCgpKSB7CisgICAgICAgICAgICAgICAgYy0+c2V0U2hhcmVk R3JhcGhpY3NDb250ZXh0M0QobV9jb250ZXh0M0QuZ2V0KCksIG1fZHJhd2luZ0J1ZmZlci5nZXQo KSwgSW50U2l6ZShjYW52YXMoKS0+d2lkdGgoKSwgY2FudmFzKCktPmhlaWdodCgpKSk7CiAjaWYg VVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQotICAgICAgICAgICAgUmVuZGVyQm94KiByZW5k ZXJCb3ggPSBjYW52YXMoKS0+cmVuZGVyQm94KCk7Ci0gICAgICAgICAgICBpZiAocmVuZGVyQm94 ICYmIHJlbmRlckJveC0+aGFzTGF5ZXIoKSAmJiByZW5kZXJCb3gtPmxheWVyKCktPmhhc0FjY2Vs ZXJhdGVkQ29tcG9zaXRpbmcoKSkKLSAgICAgICAgICAgICAgICByZW5kZXJCb3gtPmxheWVyKCkt PmNvbnRlbnRDaGFuZ2VkKFJlbmRlckxheWVyOjpDYW52YXNDaGFuZ2VkKTsKKyAgICAgICAgICAg ICAgICBSZW5kZXJCb3gqIHJlbmRlckJveCA9IGNhbnZhcygpLT5yZW5kZXJCb3goKTsKKyAgICAg ICAgICAgICAgICBpZiAocmVuZGVyQm94ICYmIHJlbmRlckJveC0+aGFzTGF5ZXIoKSAmJiByZW5k ZXJCb3gtPmxheWVyKCktPmhhc0FjY2VsZXJhdGVkQ29tcG9zaXRpbmcoKSkKKyAgICAgICAgICAg ICAgICAgICAgcmVuZGVyQm94LT5sYXllcigpLT5jb250ZW50Q2hhbmdlZChSZW5kZXJMYXllcjo6 Q2FudmFzQ2hhbmdlZCk7CiAjZW5kaWYKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAg ICAgICAgYy0+c2V0U2hhcmVkR3JhcGhpY3NDb250ZXh0M0QoMCwgMCwgSW50U2l6ZSgpKTsKKyAg ICAgICAgICAgICAgICBtX2RyYXdpbmdCdWZmZXIuY2xlYXIoKTsKKyAgICAgICAgICAgICAgICBt X2NvbnRleHQzRC5jbGVhcigpOworICAgICAgICAgICAgfQogICAgICAgICB9CiAgICAgfQogI2Vu ZGlmCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9EcmF3 aW5nQnVmZmVyQ2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL0RyYXdpbmdCdWZmZXJDaHJvbWl1bS5jcHAJKHJldmlzaW9u IDgyNzA2KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRHJh d2luZ0J1ZmZlckNocm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjQsNyArNjQsMTAgQEAg c3RhdGljIHVuc2lnbmVkIGdlbmVyYXRlQ29sb3JUZXh0dXJlKEdyYQogICAgIGNvbnRleHQtPnRl eFBhcmFtZXRlcmkoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQsIEdyYXBoaWNzQ29udGV4 dDNEOjpURVhUVVJFX01JTl9GSUxURVIsIEdyYXBoaWNzQ29udGV4dDNEOjpORUFSRVNUKTsKICAg ICBjb250ZXh0LT50ZXhQYXJhbWV0ZXJpKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBH cmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV9XUkFQX1MsIEdyYXBoaWNzQ29udGV4dDNEOjpDTEFN UF9UT19FREdFKTsKICAgICBjb250ZXh0LT50ZXhQYXJhbWV0ZXJpKEdyYXBoaWNzQ29udGV4dDNE OjpURVhUVVJFXzJELCBHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV9XUkFQX1QsIEdyYXBoaWNz Q29udGV4dDNEOjpDTEFNUF9UT19FREdFKTsKLSAgICBjb250ZXh0LT50ZXhJbWFnZTJEUmVzb3Vy Y2VTYWZlKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCAwLCBHcmFwaGljc0NvbnRleHQz RDo6UkdCQSwgc2l6ZS53aWR0aCgpLCBzaXplLmhlaWdodCgpLCAwLCBHcmFwaGljc0NvbnRleHQz RDo6UkdCQSwgR3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZVEUpOworICAgIGlmICghY29u dGV4dC0+dGV4SW1hZ2UyRFJlc291cmNlU2FmZShHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV8y RCwgMCwgR3JhcGhpY3NDb250ZXh0M0Q6OlJHQkEsIHNpemUud2lkdGgoKSwgc2l6ZS5oZWlnaHQo KSwgMCwgR3JhcGhpY3NDb250ZXh0M0Q6OlJHQkEsIEdyYXBoaWNzQ29udGV4dDNEOjpVTlNJR05F RF9CWVRFKSkgeworICAgICAgICBjb250ZXh0LT5kZWxldGVUZXh0dXJlKG9mZnNjcmVlbkNvbG9y VGV4dHVyZSk7CisgICAgICAgIHJldHVybiAwOworICAgIH0KICAgICBjb250ZXh0LT5mcmFtZWJ1 ZmZlclRleHR1cmUyRChHcmFwaGljc0NvbnRleHQzRDo6RlJBTUVCVUZGRVIsIEdyYXBoaWNzQ29u dGV4dDNEOjpDT0xPUl9BVFRBQ0hNRU5UMCwgR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQs IG9mZnNjcmVlbkNvbG9yVGV4dHVyZSwgMCk7CiAKICAgICByZXR1cm4gb2Zmc2NyZWVuQ29sb3JU ZXh0dXJlOwpJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0RyYXdp bmdCdWZmZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2dwdS9EcmF3aW5nQnVmZmVyLmNwcAkocmV2aXNpb24gODI3MDYpCisrKyBTb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1ZmZlci5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTE5MCw3ICsxOTAsMTAgQEAgdm9pZCBEcmF3aW5nQnVmZmVyOjpyZXNldChjb25zdCBJ bnRTaXplJgogICAgIG1fY29udGV4dC0+YmluZEZyYW1lYnVmZmVyKEdyYXBoaWNzQ29udGV4dDNE OjpGUkFNRUJVRkZFUiwgbV9mYm8pOwogCiAgICAgbV9jb250ZXh0LT5iaW5kVGV4dHVyZShHcmFw aGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRCwgbV9jb2xvckJ1ZmZlcik7Ci0gICAgbV9jb250ZXh0 LT50ZXhJbWFnZTJEUmVzb3VyY2VTYWZlKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCAw LCBpbnRlcm5hbENvbG9yRm9ybWF0LCBtX3NpemUud2lkdGgoKSwgbV9zaXplLmhlaWdodCgpLCAw LCBjb2xvckZvcm1hdCwgR3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZVEUpOworICAgIGlm ICghbV9jb250ZXh0LT50ZXhJbWFnZTJEUmVzb3VyY2VTYWZlKEdyYXBoaWNzQ29udGV4dDNEOjpU RVhUVVJFXzJELCAwLCBpbnRlcm5hbENvbG9yRm9ybWF0LCBtX3NpemUud2lkdGgoKSwgbV9zaXpl LmhlaWdodCgpLCAwLCBjb2xvckZvcm1hdCwgR3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZ VEUpKSB7CisgICAgICAgIGNsZWFyKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CiAgICAgbV9j b250ZXh0LT5mcmFtZWJ1ZmZlclRleHR1cmUyRChHcmFwaGljc0NvbnRleHQzRDo6RlJBTUVCVUZG RVIsIEdyYXBoaWNzQ29udGV4dDNEOjpDT0xPUl9BVFRBQ0hNRU5UMCwgR3JhcGhpY3NDb250ZXh0 M0Q6OlRFWFRVUkVfMkQsIG1fY29sb3JCdWZmZXIsIDApOwogICAgIG1fY29udGV4dC0+YmluZFRl eHR1cmUoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQsIDApOwogICAgIGlmICghbXVsdGlz YW1wbGUoKSkKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9EcmF3 aW5nQnVmZmVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvZ3B1L0RyYXdpbmdCdWZmZXIuaAkocmV2aXNpb24gODI3MDYpCisrKyBTb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1ZmZlci5oCSh3b3JraW5nIGNvcHkpCkBA IC02NSw2ICs2NSw4IEBAIHB1YmxpYzoKICAgICBJbnRTaXplIHNpemUoKSBjb25zdCB7IHJldHVy biBtX3NpemU7IH0KICAgICBQbGF0Zm9ybTNET2JqZWN0IGNvbG9yQnVmZmVyKCkgY29uc3QgeyBy ZXR1cm4gbV9jb2xvckJ1ZmZlcjsgfQogCisgICAgYm9vbCBpc1ZhbGlkKCkgY29uc3QgeyByZXR1 cm4gbV9jb250ZXh0OyB9CisKICAgICAvLyBDbGVhciBhbGwgcmVzb3VyY2VzIGZyb20gdGhpcyBv YmplY3QsIGFzIHdlbGwgYXMgY29udGV4dC4gQ2FsbGVkIHdoZW4gY29udGV4dCBpcyBkZXN0cm95 ZWQKICAgICAvLyB0byBwcmV2ZW50IGludmFsaWQgYWNjZXNzZXMgdG8gdGhlIHJlc291cmNlcy4K ICAgICB2b2lkIGNsZWFyKCk7CkluZGV4OiBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxv Zwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwkocmV2aXNp b24gODI4NTIpCisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwkod29ya2luZyBj b3B5KQpAQCAtMSwzICsxLDIxIEBACisyMDExLTA0LTAxICBKZWZmIFRpbWFudXMgIDx0d2l6QGNo cm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBTeW50aGVzaXplIGEgR0wgZXJyb3Igd2hlbiByZXF1ZXN0aW5nIGEgdGV4dHVyZSB0aGF0 IGlzIGxhcmdlciB0aGFuIHRoZQorICAgICAgICBzdXBwb3J0ZWQgbWF4aW11bSBkaW1lbnNpb25z IG9mIHRoZSBob3N0aW5nIEdMIGltcGxlbWVudGF0aW9uLgorICAgICAgICBBbHNvLCBlbnN1cmUg dGhhdCB0aGUgYWNjZWxlcmF0ZWQgY2FudmFzIHBhdGggbmV2ZXIgdXNlcyBhbiBpbnZhbGlkCisg ICAgICAgIERyYXdpbmdCdWZmZXIuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD01Nzc2OAorCisgICAgICAgIFRlc3RzOiBmYXN0L2NhbnZhcy9jYW52YXMt bGFyZ2UtZGltZW5zaW9ucy5odG1sCisKKyAgICAgICAgKiBzcmMvR3JhcGhpY3NDb250ZXh0M0RD aHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzREludGVybmFs OjpHcmFwaGljc0NvbnRleHQzREludGVybmFsKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNz Q29udGV4dDNESW50ZXJuYWw6OmluaXRpYWxpemUpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhp Y3NDb250ZXh0M0RJbnRlcm5hbDo6dGV4SW1hZ2UyRCk6CisgICAgICAgICogc3JjL0dyYXBoaWNz Q29udGV4dDNESW50ZXJuYWwuaDoKKwogMjAxMS0wNC0wMSAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3 ZWJraXQub3JnPgogCiAgICAgICAgIEF0dGVtcHQgdG8gZml4IHRoZSBDaHJvbWl1bSBidWlsZCB1 c2luZyB0aGUgZ3JlYXQgYW5kIHBvd2VyZnVsIGdpdC4KSW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwCShy ZXZpc2lvbiA4MjcwNikKKysrIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29u dGV4dDNEQ2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC04Myw2ICs4Myw3IEBAIEdyYXBo aWNzQ29udGV4dDNESW50ZXJuYWw6OkdyYXBoaWNzQ29udGUKICAgICA6IG1fd2ViVmlld0ltcGwo MCkKICAgICAsIG1faW5pdGlhbGl6ZWRBdmFpbGFibGVFeHRlbnNpb25zKGZhbHNlKQogICAgICwg bV9sYXllckNvbXBvc2l0ZWQoZmFsc2UpCisgICAgLCBtX21heFRleHR1cmVTaXplKDApCiAjaWYg VVNFKFNLSUEpCiAjZWxpZiBQTEFURk9STShDRykKICAgICAsIG1fcmVuZGVyT3V0cHV0KDApCkBA IC0xMjksNiArMTMwLDggQEAgYm9vbCBHcmFwaGljc0NvbnRleHQzREludGVybmFsOjppbml0aWFs aQogI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKICAgICBtX2NvbXBvc2l0aW5nTGF5 ZXIgPSBXZWJHTExheWVyQ2hyb21pdW06OmNyZWF0ZSgwKTsKICNlbmRpZgorCisgICAgbV9pbXBs LT5nZXRJbnRlZ2VydihHcmFwaGljc0NvbnRleHQzRDo6TUFYX1RFWFRVUkVfU0laRSwgJm1fbWF4 VGV4dHVyZVNpemUpOwogICAgIHJldHVybiB0cnVlOwogfQogCkBAIC02MTIsNiArNjE1LDEwIEBA IERFTEVHQVRFX1RPX0lNUExfNChzdGVuY2lsT3BTZXBhcmF0ZSwgR0MKIAogYm9vbCBHcmFwaGlj c0NvbnRleHQzREludGVybmFsOjp0ZXhJbWFnZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBs ZXZlbCwgR0MzRGVudW0gaW50ZXJuYWxmb3JtYXQsIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVp IGhlaWdodCwgR0MzRGludCBib3JkZXIsIEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVudW0gdHlwZSwg Y29uc3Qgdm9pZCogcGl4ZWxzKQogeworICAgIGlmICh3aWR0aCA+IG1fbWF4VGV4dHVyZVNpemUg fHwgaGVpZ2h0ID4gbV9tYXhUZXh0dXJlU2l6ZSkgeworICAgICAgc3ludGhlc2l6ZUdMRXJyb3Io R3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUUpOworICAgICAgcmV0dXJuIGZhbHNlOwor ICAgIH0KICAgICBtX2ltcGwtPnRleEltYWdlMkQodGFyZ2V0LCBsZXZlbCwgaW50ZXJuYWxmb3Jt YXQsIHdpZHRoLCBoZWlnaHQsIGJvcmRlciwgZm9ybWF0LCB0eXBlLCBwaXhlbHMpOwogICAgIHJl dHVybiB0cnVlOwogfQpJbmRleDogU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3ND b250ZXh0M0RJbnRlcm5hbC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL0dyYXBoaWNzQ29udGV4dDNESW50ZXJuYWwuaAkocmV2aXNpb24gODI3MDYpCisrKyBTb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzREludGVybmFsLmgJKHdvcmtp bmcgY29weSkKQEAgLTI3OSw2ICsyNzksNyBAQCBwcml2YXRlOgogICAgIEhhc2hTZXQ8U3RyaW5n PiBtX2VuYWJsZWRFeHRlbnNpb25zOwogICAgIEhhc2hTZXQ8U3RyaW5nPiBtX3JlcXVlc3RhYmxl RXh0ZW5zaW9uczsKICAgICBib29sIG1fbGF5ZXJDb21wb3NpdGVkOworICAgIEdDM0RpbnQgbV9t YXhUZXh0dXJlU2l6ZTsKICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCiAgICAgUmVm UHRyPFdlYkdMTGF5ZXJDaHJvbWl1bT4gbV9jb21wb3NpdGluZ0xheWVyOwogI2VuZGlmCkluZGV4 OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCShyZXZpc2lvbiA4Mjg1MikKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBj b3B5KQpAQCAtMSwzICsxLDE1IEBACisyMDExLTA0LTA0ICBKZWZmIFRpbWFudXMgIDx0d2l6QGNo cm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBTeW50aGVzaXplIGEgR0wgZXJyb3Igd2hlbiByZXF1ZXN0aW5nIGEgdGV4dHVyZSB0aGF0 IGlzIGxhcmdlciB0aGFuIHRoZQorICAgICAgICBzdXBwb3J0ZWQgbWF4aW11bSBkaW1lbnNpb25z IG9mIHRoZSBob3N0aW5nIEdMIGltcGxlbWVudGF0aW9uLgorICAgICAgICBBbHNvLCBlbnN1cmUg dGhhdCB0aGUgYWNjZWxlcmF0ZWQgY2FudmFzIHBhdGggbmV2ZXIgdXNlcyBhbiBpbnZhbGlkCisg ICAgICAgIERyYXdpbmdCdWZmZXIuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD01Nzc2OAorCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vdGVzdF9l eHBlY3RhdGlvbnMudHh0OgorCiAyMDExLTA0LTA0ICBDaGFuZyBTaHUgIDxjc2h1QHdlYmtpdC5v cmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCkluZGV4OiBMYXlvdXRUZXN0 cy9wbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g TGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vdGVzdF9leHBlY3RhdGlvbnMudHh0CShyZXZp c2lvbiA4MjcwNikKKysrIExheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL3Rlc3RfZXhwZWN0 YXRpb25zLnR4dAkod29ya2luZyBjb3B5KQpAQCAtMjkzMCw5ICsyOTMwLDYgQEAgQlVHQ1I2MDk2 NSBHUFUgV0lOIExJTlVYIDogZmFzdC9jYW52YXMvcwogCiBCVUdOT05FIFNMT1cgR1BVIERFQlVH IFdJTiA6IGZhc3QvY2FudmFzL2NhbnZhcy1nZXRJbWFnZURhdGEuaHRtbCA9IFBBU1MKIAotLy8g U3RhcnRlZCBmYWlsaW5nIGFmdGVyIHI3NTY0OCBvbiBldmVyeXRoaW5nIGV4Y2VwdCBTbm93IExl b3BhcmQKLUJVR1dLNTIzNDEgR1BVIDogZmFzdC9jYW52YXMvY2FudmFzLWxhcmdlLWRpbWVuc2lv bnMuaHRtbCA9IFRFWFQKLQogQlVHV0s1MzQ2OSBHUFUgTUFDIDogY29tcG9zaXRpbmcvc2Nyb2xs LXBhaW50ZWQtY29tcG9zaXRlZC1jb250ZW50Lmh0bWwgPSBDUkFTSAogCiBCVUdDUjc0OTc5IEdQ VSBNQUM6IG1lZGlhL3ZpZGVvLWNhbnZhcy1hbHBoYS5odG1sID0gSU1BR0UK 88115 2011-04-04 13:37:22 -0700 2011-04-07 10:17:43 -0700 Patch bug-57768-20110404163512.patch text/plain 11221 twiz SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDgyODUyKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjUgQEAKKzIwMTEtMDQtMDEgIEplZmYgVGlt YW51cyAgPHR3aXpAY2hyb21pdW0ub3JnPgorCisgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICBTeW50aGVzaXplIGEgR0wgZXJyb3Igd2hlbiByZXF1ZXN0aW5nIGEg dGV4dHVyZSB0aGF0IGlzIGxhcmdlciB0aGFuIHRoZQorICAgICAgIHN1cHBvcnRlZCBtYXhpbXVt IGRpbWVuc2lvbnMgb2YgdGhlIGhvc3RpbmcgR0wgaW1wbGVtZW50YXRpb24uCisgICAgICAgQWxz bywgZW5zdXJlIHRoYXQgdGhlIGFjY2VsZXJhdGVkIGNhbnZhcyBwYXRoIG5ldmVyIHVzZXMgYW4g aW52YWxpZAorICAgICAgIERyYXdpbmdCdWZmZXIuCisgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTU3NzY4CisKKyAgICAgICAgVGVzdHM6IGZhc3QvY2FudmFz L2NhbnZhcy1sYXJnZS1kaW1lbnNpb25zLmh0bWwKKworICAgICAgICAqIGh0bWwvY2FudmFzL0Nh bnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDYW52YXNSZW5k ZXJpbmdDb250ZXh0MkQ6OkNhbnZhc1JlbmRlcmluZ0NvbnRleHQyRCk6CisgICAgICAgIChXZWJD b3JlOjpDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQ6OnJlc2V0KToKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9EcmF3aW5nQnVmZmVyQ2hyb21pdW0uY3BwOgorICAgICAgICAo V2ViQ29yZTo6Z2VuZXJhdGVDb2xvclRleHR1cmUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL2dwdS9EcmF3aW5nQnVmZmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRyYXdpbmdCdWZm ZXI6OnJlc2V0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1ZmZl ci5oOgorICAgICAgICAoV2ViQ29yZTo6RHJhd2luZ0J1ZmZlcjo6aXNWYWxpZCk6CisKIDIwMTEt MDQtMDQgIE1hbGNvbG0gTWFjTGVvZCAgPG1tYWNsZW9kQHdlYm1haWwuY28uemE+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgS2V2aW4gT2xsaXZpZXIuCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9odG1s L2NhbnZhcy9DYW52YXNSZW5kZXJpbmdDb250ZXh0MkQuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9XZWJDb3JlL2h0bWwvY2FudmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHAJKHJldmlz aW9uIDgyNzA2KQorKysgU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvQ2FudmFzUmVuZGVyaW5n Q29udGV4dDJELmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTMzLDcgKzEzMywxMiBAQCBDYW52YXNS ZW5kZXJpbmdDb250ZXh0MkQ6OkNhbnZhc1JlbmRlcmluCiAgICAgICAgIG1fY29udGV4dDNEID0g cC0+c2hhcmVkR3JhcGhpY3NDb250ZXh0M0QoKTsKICAgICAgICAgaWYgKG1fY29udGV4dDNEKSB7 CiAgICAgICAgICAgICBtX2RyYXdpbmdCdWZmZXIgPSBtX2NvbnRleHQzRC0+Z3JhcGhpY3NDb250 ZXh0M0QoKS0+Y3JlYXRlRHJhd2luZ0J1ZmZlcihJbnRTaXplKGNhbnZhcy0+d2lkdGgoKSwgY2Fu dmFzLT5oZWlnaHQoKSkpOwotICAgICAgICAgICAgYy0+c2V0U2hhcmVkR3JhcGhpY3NDb250ZXh0 M0QobV9jb250ZXh0M0QuZ2V0KCksIG1fZHJhd2luZ0J1ZmZlci5nZXQoKSwgSW50U2l6ZShjYW52 YXMtPndpZHRoKCksIGNhbnZhcy0+aGVpZ2h0KCkpKTsKKyAgICAgICAgICAgIGlmICghbV9kcmF3 aW5nQnVmZmVyLT5pc1ZhbGlkKCkpIHsKKyAgICAgICAgICAgICAgICBjLT5zZXRTaGFyZWRHcmFw aGljc0NvbnRleHQzRCgwLCAwLCBJbnRTaXplKCkpOworICAgICAgICAgICAgICAgIG1fZHJhd2lu Z0J1ZmZlci5jbGVhcigpOworICAgICAgICAgICAgICAgIG1fY29udGV4dDNELmNsZWFyKCk7Cisg ICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICBjLT5zZXRTaGFyZWRHcmFwaGljc0Nv bnRleHQzRChtX2NvbnRleHQzRC5nZXQoKSwgbV9kcmF3aW5nQnVmZmVyLmdldCgpLCBJbnRTaXpl KGNhbnZhcy0+d2lkdGgoKSwgY2FudmFzLT5oZWlnaHQoKSkpOwogICAgICAgICB9CiAgICAgfQog I2VuZGlmCkBAIC0xNzMsMTIgKzE3OCwxOCBAQCB2b2lkIENhbnZhc1JlbmRlcmluZ0NvbnRleHQy RDo6cmVzZXQoKQogICAgIGlmIChHcmFwaGljc0NvbnRleHQqIGMgPSBkcmF3aW5nQ29udGV4dCgp KSB7CiAgICAgICAgIGlmIChtX2NvbnRleHQzRCAmJiBtX2RyYXdpbmdCdWZmZXIpIHsKICAgICAg ICAgICAgIG1fZHJhd2luZ0J1ZmZlci0+cmVzZXQoSW50U2l6ZShjYW52YXMoKS0+d2lkdGgoKSwg Y2FudmFzKCktPmhlaWdodCgpKSk7Ci0gICAgICAgICAgICBjLT5zZXRTaGFyZWRHcmFwaGljc0Nv bnRleHQzRChtX2NvbnRleHQzRC5nZXQoKSwgbV9kcmF3aW5nQnVmZmVyLmdldCgpLCBJbnRTaXpl KGNhbnZhcygpLT53aWR0aCgpLCBjYW52YXMoKS0+aGVpZ2h0KCkpKTsKKyAgICAgICAgICAgIGlm IChtX2RyYXdpbmdCdWZmZXItPmlzVmFsaWQoKSkgeworICAgICAgICAgICAgICAgIGMtPnNldFNo YXJlZEdyYXBoaWNzQ29udGV4dDNEKG1fY29udGV4dDNELmdldCgpLCBtX2RyYXdpbmdCdWZmZXIu Z2V0KCksIEludFNpemUoY2FudmFzKCktPndpZHRoKCksIGNhbnZhcygpLT5oZWlnaHQoKSkpOwog I2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKLSAgICAgICAgICAgIFJlbmRlckJveCog cmVuZGVyQm94ID0gY2FudmFzKCktPnJlbmRlckJveCgpOwotICAgICAgICAgICAgaWYgKHJlbmRl ckJveCAmJiByZW5kZXJCb3gtPmhhc0xheWVyKCkgJiYgcmVuZGVyQm94LT5sYXllcigpLT5oYXNB Y2NlbGVyYXRlZENvbXBvc2l0aW5nKCkpCi0gICAgICAgICAgICAgICAgcmVuZGVyQm94LT5sYXll cigpLT5jb250ZW50Q2hhbmdlZChSZW5kZXJMYXllcjo6Q2FudmFzQ2hhbmdlZCk7CisgICAgICAg ICAgICAgICAgUmVuZGVyQm94KiByZW5kZXJCb3ggPSBjYW52YXMoKS0+cmVuZGVyQm94KCk7Cisg ICAgICAgICAgICAgICAgaWYgKHJlbmRlckJveCAmJiByZW5kZXJCb3gtPmhhc0xheWVyKCkgJiYg cmVuZGVyQm94LT5sYXllcigpLT5oYXNBY2NlbGVyYXRlZENvbXBvc2l0aW5nKCkpCisgICAgICAg ICAgICAgICAgICAgIHJlbmRlckJveC0+bGF5ZXIoKS0+Y29udGVudENoYW5nZWQoUmVuZGVyTGF5 ZXI6OkNhbnZhc0NoYW5nZWQpOwogI2VuZGlmCisgICAgICAgICAgICB9IGVsc2UgeworICAgICAg ICAgICAgICAgIGMtPnNldFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEKDAsIDAsIEludFNpemUoKSk7 CisgICAgICAgICAgICAgICAgbV9kcmF3aW5nQnVmZmVyLmNsZWFyKCk7CisgICAgICAgICAgICAg ICAgbV9jb250ZXh0M0QuY2xlYXIoKTsKKyAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0K ICNlbmRpZgpJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v RHJhd2luZ0J1ZmZlckNocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9EcmF3aW5nQnVmZmVyQ2hyb21pdW0uY3BwCShyZXZp c2lvbiA4MjcwNikKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0RyYXdpbmdCdWZmZXJDaHJvbWl1bS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTY0LDcgKzY0LDEw IEBAIHN0YXRpYyB1bnNpZ25lZCBnZW5lcmF0ZUNvbG9yVGV4dHVyZShHcmEKICAgICBjb250ZXh0 LT50ZXhQYXJhbWV0ZXJpKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBHcmFwaGljc0Nv bnRleHQzRDo6VEVYVFVSRV9NSU5fRklMVEVSLCBHcmFwaGljc0NvbnRleHQzRDo6TkVBUkVTVCk7 CiAgICAgY29udGV4dC0+dGV4UGFyYW1ldGVyaShHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV8y RCwgR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfV1JBUF9TLCBHcmFwaGljc0NvbnRleHQzRDo6 Q0xBTVBfVE9fRURHRSk7CiAgICAgY29udGV4dC0+dGV4UGFyYW1ldGVyaShHcmFwaGljc0NvbnRl eHQzRDo6VEVYVFVSRV8yRCwgR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfV1JBUF9ULCBHcmFw aGljc0NvbnRleHQzRDo6Q0xBTVBfVE9fRURHRSk7Ci0gICAgY29udGV4dC0+dGV4SW1hZ2UyRFJl c291cmNlU2FmZShHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRCwgMCwgR3JhcGhpY3NDb250 ZXh0M0Q6OlJHQkEsIHNpemUud2lkdGgoKSwgc2l6ZS5oZWlnaHQoKSwgMCwgR3JhcGhpY3NDb250 ZXh0M0Q6OlJHQkEsIEdyYXBoaWNzQ29udGV4dDNEOjpVTlNJR05FRF9CWVRFKTsKKyAgICBpZiAo IWNvbnRleHQtPnRleEltYWdlMkRSZXNvdXJjZVNhZmUoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRV UkVfMkQsIDAsIEdyYXBoaWNzQ29udGV4dDNEOjpSR0JBLCBzaXplLndpZHRoKCksIHNpemUuaGVp Z2h0KCksIDAsIEdyYXBoaWNzQ29udGV4dDNEOjpSR0JBLCBHcmFwaGljc0NvbnRleHQzRDo6VU5T SUdORURfQllURSkpIHsKKyAgICAgICAgY29udGV4dC0+ZGVsZXRlVGV4dHVyZShvZmZzY3JlZW5D b2xvclRleHR1cmUpOworICAgICAgICByZXR1cm4gMDsKKyAgICB9CiAgICAgY29udGV4dC0+ZnJh bWVidWZmZXJUZXh0dXJlMkQoR3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSLCBHcmFwaGlj c0NvbnRleHQzRDo6Q09MT1JfQVRUQUNITUVOVDAsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJF XzJELCBvZmZzY3JlZW5Db2xvclRleHR1cmUsIDApOwogCiAgICAgcmV0dXJuIG9mZnNjcmVlbkNv bG9yVGV4dHVyZTsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9E cmF3aW5nQnVmZmVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9ncHUvRHJhd2luZ0J1ZmZlci5jcHAJKHJldmlzaW9uIDgyNzA2KQorKysgU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0RyYXdpbmdCdWZmZXIuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC0xOTAsNyArMTkwLDEwIEBAIHZvaWQgRHJhd2luZ0J1ZmZlcjo6cmVzZXQoY29u c3QgSW50U2l6ZSYKICAgICBtX2NvbnRleHQtPmJpbmRGcmFtZWJ1ZmZlcihHcmFwaGljc0NvbnRl eHQzRDo6RlJBTUVCVUZGRVIsIG1fZmJvKTsKIAogICAgIG1fY29udGV4dC0+YmluZFRleHR1cmUo R3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQsIG1fY29sb3JCdWZmZXIpOwotICAgIG1fY29u dGV4dC0+dGV4SW1hZ2UyRFJlc291cmNlU2FmZShHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV8y RCwgMCwgaW50ZXJuYWxDb2xvckZvcm1hdCwgbV9zaXplLndpZHRoKCksIG1fc2l6ZS5oZWlnaHQo KSwgMCwgY29sb3JGb3JtYXQsIEdyYXBoaWNzQ29udGV4dDNEOjpVTlNJR05FRF9CWVRFKTsKKyAg ICBpZiAoIW1fY29udGV4dC0+dGV4SW1hZ2UyRFJlc291cmNlU2FmZShHcmFwaGljc0NvbnRleHQz RDo6VEVYVFVSRV8yRCwgMCwgaW50ZXJuYWxDb2xvckZvcm1hdCwgbV9zaXplLndpZHRoKCksIG1f c2l6ZS5oZWlnaHQoKSwgMCwgY29sb3JGb3JtYXQsIEdyYXBoaWNzQ29udGV4dDNEOjpVTlNJR05F RF9CWVRFKSkgeworICAgICAgICBjbGVhcigpOworICAgICAgICByZXR1cm47CisgICAgfQogICAg IG1fY29udGV4dC0+ZnJhbWVidWZmZXJUZXh0dXJlMkQoR3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1F QlVGRkVSLCBHcmFwaGljc0NvbnRleHQzRDo6Q09MT1JfQVRUQUNITUVOVDAsIEdyYXBoaWNzQ29u dGV4dDNEOjpURVhUVVJFXzJELCBtX2NvbG9yQnVmZmVyLCAwKTsKICAgICBtX2NvbnRleHQtPmJp bmRUZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCAwKTsKICAgICBpZiAoIW11 bHRpc2FtcGxlKCkpCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUv RHJhd2luZ0J1ZmZlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dwdS9EcmF3aW5nQnVmZmVyLmgJKHJldmlzaW9uIDgyNzA2KQorKysgU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0RyYXdpbmdCdWZmZXIuaAkod29ya2luZyBjb3B5 KQpAQCAtNjUsNiArNjUsOCBAQCBwdWJsaWM6CiAgICAgSW50U2l6ZSBzaXplKCkgY29uc3QgeyBy ZXR1cm4gbV9zaXplOyB9CiAgICAgUGxhdGZvcm0zRE9iamVjdCBjb2xvckJ1ZmZlcigpIGNvbnN0 IHsgcmV0dXJuIG1fY29sb3JCdWZmZXI7IH0KIAorICAgIGJvb2wgaXNWYWxpZCgpIGNvbnN0IHsg cmV0dXJuIG1fY29udGV4dDsgfQorCiAgICAgLy8gQ2xlYXIgYWxsIHJlc291cmNlcyBmcm9tIHRo aXMgb2JqZWN0LCBhcyB3ZWxsIGFzIGNvbnRleHQuIENhbGxlZCB3aGVuIGNvbnRleHQgaXMgZGVz dHJveWVkCiAgICAgLy8gdG8gcHJldmVudCBpbnZhbGlkIGFjY2Vzc2VzIHRvIHRoZSByZXNvdXJj ZXMuCiAgICAgdm9pZCBjbGVhcigpOwpJbmRleDogU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFu Z2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cJKHJl dmlzaW9uIDgyODUyKQorKysgU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cJKHdvcmtp bmcgY29weSkKQEAgLTEsMyArMSwyMSBAQAorMjAxMS0wNC0wMSAgSmVmZiBUaW1hbnVzICA8dHdp ekBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgU3ludGhlc2l6ZSBhIEdMIGVycm9yIHdoZW4gcmVxdWVzdGluZyBhIHRleHR1cmUg dGhhdCBpcyBsYXJnZXIgdGhhbiB0aGUKKyAgICAgICAgc3VwcG9ydGVkIG1heGltdW0gZGltZW5z aW9ucyBvZiB0aGUgaG9zdGluZyBHTCBpbXBsZW1lbnRhdGlvbi4KKyAgICAgICAgQWxzbywgZW5z dXJlIHRoYXQgdGhlIGFjY2VsZXJhdGVkIGNhbnZhcyBwYXRoIG5ldmVyIHVzZXMgYW4gaW52YWxp ZAorICAgICAgICBEcmF3aW5nQnVmZmVyLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9NTc3NjgKKworICAgICAgICBUZXN0czogZmFzdC9jYW52YXMvY2Fu dmFzLWxhcmdlLWRpbWVuc2lvbnMuaHRtbAorCisgICAgICAgICogc3JjL0dyYXBoaWNzQ29udGV4 dDNEQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RJbnRl cm5hbDo6R3JhcGhpY3NDb250ZXh0M0RJbnRlcm5hbCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFw aGljc0NvbnRleHQzREludGVybmFsOjppbml0aWFsaXplKToKKyAgICAgICAgKFdlYkNvcmU6Okdy YXBoaWNzQ29udGV4dDNESW50ZXJuYWw6OnRleEltYWdlMkQpOgorICAgICAgICAqIHNyYy9HcmFw aGljc0NvbnRleHQzREludGVybmFsLmg6CisKIDIwMTEtMDQtMDEgIEFkYW0gQmFydGggIDxhYmFy dGhAd2Via2l0Lm9yZz4KIAogICAgICAgICBBdHRlbXB0IHRvIGZpeCB0aGUgQ2hyb21pdW0gYnVp bGQgdXNpbmcgdGhlIGdyZWF0IGFuZCBwb3dlcmZ1bCBnaXQuCkluZGV4OiBTb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNw cAkocmV2aXNpb24gODI3MDYpCisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGlj c0NvbnRleHQzRENocm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtODMsNiArODMsNyBAQCBH cmFwaGljc0NvbnRleHQzREludGVybmFsOjpHcmFwaGljc0NvbnRlCiAgICAgOiBtX3dlYlZpZXdJ bXBsKDApCiAgICAgLCBtX2luaXRpYWxpemVkQXZhaWxhYmxlRXh0ZW5zaW9ucyhmYWxzZSkKICAg ICAsIG1fbGF5ZXJDb21wb3NpdGVkKGZhbHNlKQorICAgICwgbV9tYXhUZXh0dXJlU2l6ZSgwKQog I2lmIFVTRShTS0lBKQogI2VsaWYgUExBVEZPUk0oQ0cpCiAgICAgLCBtX3JlbmRlck91dHB1dCgw KQpAQCAtMTI5LDYgKzEzMCw4IEBAIGJvb2wgR3JhcGhpY3NDb250ZXh0M0RJbnRlcm5hbDo6aW5p dGlhbGkKICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCiAgICAgbV9jb21wb3NpdGlu Z0xheWVyID0gV2ViR0xMYXllckNocm9taXVtOjpjcmVhdGUoMCk7CiAjZW5kaWYKKworICAgIG1f aW1wbC0+Z2V0SW50ZWdlcnYoR3JhcGhpY3NDb250ZXh0M0Q6Ok1BWF9URVhUVVJFX1NJWkUsICZt X21heFRleHR1cmVTaXplKTsKICAgICByZXR1cm4gdHJ1ZTsKIH0KIApAQCAtNjEyLDYgKzYxNSwx MCBAQCBERUxFR0FURV9UT19JTVBMXzQoc3RlbmNpbE9wU2VwYXJhdGUsIEdDCiAKIGJvb2wgR3Jh cGhpY3NDb250ZXh0M0RJbnRlcm5hbDo6dGV4SW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0Rp bnQgbGV2ZWwsIEdDM0RlbnVtIGludGVybmFsZm9ybWF0LCBHQzNEc2l6ZWkgd2lkdGgsIEdDM0Rz aXplaSBoZWlnaHQsIEdDM0RpbnQgYm9yZGVyLCBHQzNEZW51bSBmb3JtYXQsIEdDM0RlbnVtIHR5 cGUsIGNvbnN0IHZvaWQqIHBpeGVscykKIHsKKyAgICBpZiAod2lkdGggPiBtX21heFRleHR1cmVT aXplIHx8IGhlaWdodCA+IG1fbWF4VGV4dHVyZVNpemUpIHsKKyAgICAgIHN5bnRoZXNpemVHTEVy cm9yKEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZBTFVFKTsKKyAgICAgIHJldHVybiBmYWxz ZTsKKyAgICB9CiAgICAgbV9pbXBsLT50ZXhJbWFnZTJEKHRhcmdldCwgbGV2ZWwsIGludGVybmFs Zm9ybWF0LCB3aWR0aCwgaGVpZ2h0LCBib3JkZXIsIGZvcm1hdCwgdHlwZSwgcGl4ZWxzKTsKICAg ICByZXR1cm4gdHJ1ZTsKIH0KSW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBo aWNzQ29udGV4dDNESW50ZXJuYWwuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9HcmFwaGljc0NvbnRleHQzREludGVybmFsLmgJKHJldmlzaW9uIDgyNzA2KQorKysg U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RJbnRlcm5hbC5oCSh3 b3JraW5nIGNvcHkpCkBAIC0yNzksNiArMjc5LDcgQEAgcHJpdmF0ZToKICAgICBIYXNoU2V0PFN0 cmluZz4gbV9lbmFibGVkRXh0ZW5zaW9uczsKICAgICBIYXNoU2V0PFN0cmluZz4gbV9yZXF1ZXN0 YWJsZUV4dGVuc2lvbnM7CiAgICAgYm9vbCBtX2xheWVyQ29tcG9zaXRlZDsKKyAgICBHQzNEaW50 IG1fbWF4VGV4dHVyZVNpemU7CiAjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQogICAg IFJlZlB0cjxXZWJHTExheWVyQ2hyb21pdW0+IG1fY29tcG9zaXRpbmdMYXllcjsKICNlbmRpZgpJ bmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0No YW5nZUxvZwkocmV2aXNpb24gODI4NTIpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtp bmcgY29weSkKQEAgLTEsMyArMSwxNSBAQAorMjAxMS0wNC0wNCAgSmVmZiBUaW1hbnVzICA8dHdp ekBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgU3ludGhlc2l6ZSBhIEdMIGVycm9yIHdoZW4gcmVxdWVzdGluZyBhIHRleHR1cmUg dGhhdCBpcyBsYXJnZXIgdGhhbiB0aGUKKyAgICAgICAgc3VwcG9ydGVkIG1heGltdW0gZGltZW5z aW9ucyBvZiB0aGUgaG9zdGluZyBHTCBpbXBsZW1lbnRhdGlvbi4KKyAgICAgICAgQWxzbywgZW5z dXJlIHRoYXQgdGhlIGFjY2VsZXJhdGVkIGNhbnZhcyBwYXRoIG5ldmVyIHVzZXMgYW4gaW52YWxp ZAorICAgICAgICBEcmF3aW5nQnVmZmVyLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9NTc3NjgKKworICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtL3Rl c3RfZXhwZWN0YXRpb25zLnR4dDoKKwogMjAxMS0wNC0wNCAgQ2hhbmcgU2h1ICA8Y3NodUB3ZWJr aXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpJbmRleDogTGF5b3V0 VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vdGVzdF9leHBlY3RhdGlvbnMudHh0Cj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAko cmV2aXNpb24gODI3MDYpCisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4 cGVjdGF0aW9ucy50eHQJKHdvcmtpbmcgY29weSkKQEAgLTI5MzAsOSArMjkzMCw2IEBAIEJVR0NS NjA5NjUgR1BVIFdJTiBMSU5VWCA6IGZhc3QvY2FudmFzL3MKIAogQlVHTk9ORSBTTE9XIEdQVSBE RUJVRyBXSU4gOiBmYXN0L2NhbnZhcy9jYW52YXMtZ2V0SW1hZ2VEYXRhLmh0bWwgPSBQQVNTCiAK LS8vIFN0YXJ0ZWQgZmFpbGluZyBhZnRlciByNzU2NDggb24gZXZlcnl0aGluZyBleGNlcHQgU25v dyBMZW9wYXJkCi1CVUdXSzUyMzQxIEdQVSA6IGZhc3QvY2FudmFzL2NhbnZhcy1sYXJnZS1kaW1l bnNpb25zLmh0bWwgPSBURVhUCi0KIEJVR1dLNTM0NjkgR1BVIE1BQyA6IGNvbXBvc2l0aW5nL3Nj cm9sbC1wYWludGVkLWNvbXBvc2l0ZWQtY29udGVudC5odG1sID0gQ1JBU0gKIAogQlVHQ1I3NDk3 OSBHUFUgTUFDOiBtZWRpYS92aWRlby1jYW52YXMtYWxwaGEuaHRtbCA9IElNQUdFCg== 88657 2011-04-07 10:17:47 -0700 2011-04-08 10:56:55 -0700 Patch bug-57768-20110407131531.patch text/plain 14414 twiz SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDgzMTMwKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTEtMDQtMDYgIEplZmYgVGlt YW51cyAgPHR3aXpAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEZhbGwgYmFjayB0byBzb2Z0d2FyZSByZW5kZXJpbmcgZm9yIENh bnZhczJEIHdoZW4gcmVxdWVzdGluZyBhIERyYXdpbmdCdWZmZXIgbGFyZ2VyIHRoYW4gc3VwcG9y dGVkIGJ5IHRoZSBHTCBlbnZpcm9ubWVudC4KKyAgICAgICAgQWxzbywgcmVzcGVjdCB0aGUgY29u dHJhY3QgcHJvdmlkZWQgYnkgZXh0ZW5zaW9uICJHTF9DSFJPTUlVTV9yZXNvdXJjZV9zYWZlIiB3 aGVuIHJlcXVlc3RpbmcgdGV4dHVyZXMgZm9yIEZCT3MgZm9yIERyYXdpbmdCdWZmZXIgaW5zdGFu Y2VzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTc3 NjgKKworICAgICAgICAqIGh0bWwvY2FudmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQ6OkNhbnZhc1JlbmRl cmluZ0NvbnRleHQyRCk6CisgICAgICAgIChXZWJDb3JlOjpDYW52YXNSZW5kZXJpbmdDb250ZXh0 MkQ6OnJlc2V0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQz RC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRDo6dGV4SW1hZ2UyRFJl c291cmNlU2FmZSk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRDo6dGV4SW1h Z2UyRFJlc291cmNlU2FmZU5vQ2xlYXIpOgorICAgICAgICBBIG5ldyB0ZXhJbWFnZTJEIGhlbHBl ciB3YXMgYWRkZWQgdGhhdCBwZXJmb3JtcyB0aGUgc2FtZSBjaGVja3MgYXMgdGV4SW1hZ2UyRFJl c291cmNlU2FmZSwgYnV0IGRvZXMgbm90IGluaXRpYWxpemUgdGhlIHRleHR1cmUgZGF0YSB0byAw LgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dDNELmg6CisgICAg ICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0RyYXdpbmdCdWZmZXIuY3BwOgorICAgICAgICAo V2ViQ29yZTo6RHJhd2luZ0J1ZmZlcjo6cmVzZXQpOgorICAgICAgICByZXNldCBub3cgcmV0dXJu cyBmYWxzZSBpZiB0aGUgcmVzaXplIGZhaWxlZCwgYW5kIGxlYXZlcyB0aGUgRHJhd2luZ0J1ZmZl ciBpbiBhIGNsZWFyZWQgc3RhdGUuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0Ry YXdpbmdCdWZmZXIuaDoKKwogMjAxMS0wNC0wNiAgU3RlcGhhbmllIExld2lzICA8c2xld2lzQGFw cGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KSW5kZXg6IFNvdXJj ZS9XZWJDb3JlL2h0bWwvY2FudmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvQ2FudmFzUmVuZGVyaW5nQ29udGV4 dDJELmNwcAkocmV2aXNpb24gODI3MDYpCisrKyBTb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9D YW52YXNSZW5kZXJpbmdDb250ZXh0MkQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMzMsNyArMTMz LDExIEBAIENhbnZhc1JlbmRlcmluZ0NvbnRleHQyRDo6Q2FudmFzUmVuZGVyaW4KICAgICAgICAg bV9jb250ZXh0M0QgPSBwLT5zaGFyZWRHcmFwaGljc0NvbnRleHQzRCgpOwogICAgICAgICBpZiAo bV9jb250ZXh0M0QpIHsKICAgICAgICAgICAgIG1fZHJhd2luZ0J1ZmZlciA9IG1fY29udGV4dDNE LT5ncmFwaGljc0NvbnRleHQzRCgpLT5jcmVhdGVEcmF3aW5nQnVmZmVyKEludFNpemUoY2FudmFz LT53aWR0aCgpLCBjYW52YXMtPmhlaWdodCgpKSk7Ci0gICAgICAgICAgICBjLT5zZXRTaGFyZWRH cmFwaGljc0NvbnRleHQzRChtX2NvbnRleHQzRC5nZXQoKSwgbV9kcmF3aW5nQnVmZmVyLmdldCgp LCBJbnRTaXplKGNhbnZhcy0+d2lkdGgoKSwgY2FudmFzLT5oZWlnaHQoKSkpOworICAgICAgICAg ICAgaWYgKCFtX2RyYXdpbmdCdWZmZXIpIHsKKyAgICAgICAgICAgICAgICBjLT5zZXRTaGFyZWRH cmFwaGljc0NvbnRleHQzRCgwLCAwLCBJbnRTaXplKCkpOworICAgICAgICAgICAgICAgIG1fY29u dGV4dDNELmNsZWFyKCk7CisgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICBjLT5z ZXRTaGFyZWRHcmFwaGljc0NvbnRleHQzRChtX2NvbnRleHQzRC5nZXQoKSwgbV9kcmF3aW5nQnVm ZmVyLmdldCgpLCBJbnRTaXplKGNhbnZhcy0+d2lkdGgoKSwgY2FudmFzLT5oZWlnaHQoKSkpOwog ICAgICAgICB9CiAgICAgfQogI2VuZGlmCkBAIC0xNzIsMTMgKzE3NiwxOCBAQCB2b2lkIENhbnZh c1JlbmRlcmluZ0NvbnRleHQyRDo6cmVzZXQoKQogI2lmIEVOQUJMRShBQ0NFTEVSQVRFRF8yRF9D QU5WQVMpCiAgICAgaWYgKEdyYXBoaWNzQ29udGV4dCogYyA9IGRyYXdpbmdDb250ZXh0KCkpIHsK ICAgICAgICAgaWYgKG1fY29udGV4dDNEICYmIG1fZHJhd2luZ0J1ZmZlcikgewotICAgICAgICAg ICAgbV9kcmF3aW5nQnVmZmVyLT5yZXNldChJbnRTaXplKGNhbnZhcygpLT53aWR0aCgpLCBjYW52 YXMoKS0+aGVpZ2h0KCkpKTsKLSAgICAgICAgICAgIGMtPnNldFNoYXJlZEdyYXBoaWNzQ29udGV4 dDNEKG1fY29udGV4dDNELmdldCgpLCBtX2RyYXdpbmdCdWZmZXIuZ2V0KCksIEludFNpemUoY2Fu dmFzKCktPndpZHRoKCksIGNhbnZhcygpLT5oZWlnaHQoKSkpOworICAgICAgICAgICAgaWYgKG1f ZHJhd2luZ0J1ZmZlci0+cmVzZXQoSW50U2l6ZShjYW52YXMoKS0+d2lkdGgoKSwgY2FudmFzKCkt PmhlaWdodCgpKSkpIHsKKyAgICAgICAgICAgICAgICBjLT5zZXRTaGFyZWRHcmFwaGljc0NvbnRl eHQzRChtX2NvbnRleHQzRC5nZXQoKSwgbV9kcmF3aW5nQnVmZmVyLmdldCgpLCBJbnRTaXplKGNh bnZhcygpLT53aWR0aCgpLCBjYW52YXMoKS0+aGVpZ2h0KCkpKTsKICNpZiBVU0UoQUNDRUxFUkFU RURfQ09NUE9TSVRJTkcpCi0gICAgICAgICAgICBSZW5kZXJCb3gqIHJlbmRlckJveCA9IGNhbnZh cygpLT5yZW5kZXJCb3goKTsKLSAgICAgICAgICAgIGlmIChyZW5kZXJCb3ggJiYgcmVuZGVyQm94 LT5oYXNMYXllcigpICYmIHJlbmRlckJveC0+bGF5ZXIoKS0+aGFzQWNjZWxlcmF0ZWRDb21wb3Np dGluZygpKQotICAgICAgICAgICAgICAgIHJlbmRlckJveC0+bGF5ZXIoKS0+Y29udGVudENoYW5n ZWQoUmVuZGVyTGF5ZXI6OkNhbnZhc0NoYW5nZWQpOworICAgICAgICAgICAgICAgIFJlbmRlckJv eCogcmVuZGVyQm94ID0gY2FudmFzKCktPnJlbmRlckJveCgpOworICAgICAgICAgICAgICAgIGlm IChyZW5kZXJCb3ggJiYgcmVuZGVyQm94LT5oYXNMYXllcigpICYmIHJlbmRlckJveC0+bGF5ZXIo KS0+aGFzQWNjZWxlcmF0ZWRDb21wb3NpdGluZygpKQorICAgICAgICAgICAgICAgICAgICByZW5k ZXJCb3gtPmxheWVyKCktPmNvbnRlbnRDaGFuZ2VkKFJlbmRlckxheWVyOjpDYW52YXNDaGFuZ2Vk KTsKICNlbmRpZgorICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICBjLT5zZXRT aGFyZWRHcmFwaGljc0NvbnRleHQzRCgwLCAwLCBJbnRTaXplKCkpOworICAgICAgICAgICAgICAg IG1fZHJhd2luZ0J1ZmZlci5jbGVhcigpOworICAgICAgICAgICAgICAgIG1fY29udGV4dDNELmNs ZWFyKCk7CisgICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICB9CiAjZW5kaWYKSW5kZXg6IFNv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dDNELmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRl eHQzRC5jcHAJKHJldmlzaW9uIDgyNzA2KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvR3JhcGhpY3NDb250ZXh0M0QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00NCwxNSArNDQs MzYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBuYW1lc3BhY2UgewogCi0gICAgdWludDhfdCBj b252ZXJ0Q29sb3IxNkxpdHRsZVRvOCh1aW50MTZfdCB2YWx1ZSkKLSAgICB7Ci0gICAgICAgIHJl dHVybiB2YWx1ZSA+PiA4OwotICAgIH0KK3VpbnQ4X3QgY29udmVydENvbG9yMTZMaXR0bGVUbzgo dWludDE2X3QgdmFsdWUpCit7CisgICAgcmV0dXJuIHZhbHVlID4+IDg7Cit9CisKK3VpbnQ4X3Qg Y29udmVydENvbG9yMTZCaWdUbzgodWludDE2X3QgdmFsdWUpCit7CisgICAgcmV0dXJuIHN0YXRp Y19jYXN0PHVpbnQ4X3Q+KHZhbHVlICYgMHgwMEZGKTsKK30KKworR0MzRGVudW0gYWxsb2NhdGVU ZXhJbWFnZTJEQnVmZmVyKE93bkFycmF5UHRyPHVuc2lnbmVkIGNoYXI+KiBidWZmZXIsIHVuc2ln bmVkIGludCogc2l6ZSwgR3JhcGhpY3NDb250ZXh0M0QqIGdyYXBoaWNzQ29udGV4dCwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBo ZWlnaHQsIEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVudW0gdHlwZSwgR0MzRGludCB1bnBhY2tBbGln bm1lbnQpCit7CisgICAgQVNTRVJUKHVucGFja0FsaWdubWVudCA9PSAxIHx8IHVucGFja0FsaWdu bWVudCA9PSAyIHx8IHVucGFja0FsaWdubWVudCA9PSA0IHx8IHVucGFja0FsaWdubWVudCA9PSA4 KTsKKyAgICAqc2l6ZSA9IDA7CisgICAgaWYgKHdpZHRoID4gMCAmJiBoZWlnaHQgPiAwKSB7Cisg ICAgICAgIEdDM0RlbnVtIGVycm9yID0gZ3JhcGhpY3NDb250ZXh0LT5jb21wdXRlSW1hZ2VTaXpl SW5CeXRlcyhmb3JtYXQsIHR5cGUsIHdpZHRoLCBoZWlnaHQsIHVucGFja0FsaWdubWVudCwgc2l6 ZSwgMCk7CisgICAgICAgIGlmIChlcnJvciAhPSBHcmFwaGljc0NvbnRleHQzRDo6Tk9fRVJST1Ip IHsKKyAgICAgICAgICAgICpzaXplID0gMDsKKyAgICAgICAgICAgIHJldHVybiBlcnJvcjsKKyAg ICAgICAgfQogCi0gICAgdWludDhfdCBjb252ZXJ0Q29sb3IxNkJpZ1RvOCh1aW50MTZfdCB2YWx1 ZSkKLSAgICB7Ci0gICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDx1aW50OF90Pih2YWx1ZSAmIDB4 MDBGRik7CisgICAgICAgICpidWZmZXIgPSBhZG9wdEFycmF5UHRyKG5ldyB1bnNpZ25lZCBjaGFy WypzaXplXSk7CisgICAgICAgIGlmICghKCpidWZmZXIpKSB7CisgICAgICAgICAgICAqc2l6ZSA9 IDA7CisgICAgICAgICAgICByZXR1cm4gR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUU7 CisgICAgICAgIH0KICAgICB9CisgICAgcmV0dXJuIEdyYXBoaWNzQ29udGV4dDNEOjpOT19FUlJP UjsKK30KIAogfSAvLyBhbm9ueW1vdXMgbmFtZXNwYWNlCiAKQEAgLTY0LDIzICs4NSwyOCBAQCBQ YXNzUmVmUHRyPERyYXdpbmdCdWZmZXI+IEdyYXBoaWNzQ29udGV4CiAKIGJvb2wgR3JhcGhpY3ND b250ZXh0M0Q6OnRleEltYWdlMkRSZXNvdXJjZVNhZmUoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50 IGxldmVsLCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6 ZWkgaGVpZ2h0LCBHQzNEaW50IGJvcmRlciwgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBl LCBHQzNEaW50IHVucGFja0FsaWdubWVudCkKIHsKLSAgICBBU1NFUlQodW5wYWNrQWxpZ25tZW50 ID09IDEgfHwgdW5wYWNrQWxpZ25tZW50ID09IDIgfHwgdW5wYWNrQWxpZ25tZW50ID09IDQgfHwg dW5wYWNrQWxpZ25tZW50ID09IDgpOwotICAgIE93bkFycmF5UHRyPHVuc2lnbmVkIGNoYXI+IHpl cm87Ci0gICAgaWYgKHdpZHRoID4gMCAmJiBoZWlnaHQgPiAwKSB7Ci0gICAgICAgIHVuc2lnbmVk IGludCBzaXplOwotICAgICAgICBHQzNEZW51bSBlcnJvciA9IGNvbXB1dGVJbWFnZVNpemVJbkJ5 dGVzKGZvcm1hdCwgdHlwZSwgd2lkdGgsIGhlaWdodCwgdW5wYWNrQWxpZ25tZW50LCAmc2l6ZSwg MCk7Ci0gICAgICAgIGlmIChlcnJvciAhPSBHcmFwaGljc0NvbnRleHQzRDo6Tk9fRVJST1IpIHsK LSAgICAgICAgICAgIHN5bnRoZXNpemVHTEVycm9yKGVycm9yKTsKLSAgICAgICAgICAgIHJldHVy biBmYWxzZTsKLSAgICAgICAgfQotICAgICAgICB6ZXJvID0gYWRvcHRBcnJheVB0cihuZXcgdW5z aWduZWQgY2hhcltzaXplXSk7Ci0gICAgICAgIGlmICghemVybykgewotICAgICAgICAgICAgc3lu dGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUUpOwotICAgICAg ICAgICAgcmV0dXJuIGZhbHNlOwotICAgICAgICB9Ci0gICAgICAgIG1lbXNldCh6ZXJvLmdldCgp LCAwLCBzaXplKTsKKyAgICBPd25BcnJheVB0cjx1bnNpZ25lZCBjaGFyPiBidWZmZXI7CisgICAg dW5zaWduZWQgaW50IHNpemU7CisgICAgR0MzRGVudW0gZXJyb3IgPSBhbGxvY2F0ZVRleEltYWdl MkRCdWZmZXIoJmJ1ZmZlciwgJnNpemUsIHRoaXMsIHdpZHRoLCBoZWlnaHQsIGZvcm1hdCwgdHlw ZSwgdW5wYWNrQWxpZ25tZW50KTsKKyAgICBpZiAoR3JhcGhpY3NDb250ZXh0M0Q6Ok5PX0VSUk9S ID09IGVycm9yKSB7CisgICAgICAgIG1lbXNldChidWZmZXIuZ2V0KCksIDAsIHNpemUpOworICAg ICAgICByZXR1cm4gdGV4SW1hZ2UyRCh0YXJnZXQsIGxldmVsLCBpbnRlcm5hbGZvcm1hdCwgd2lk dGgsIGhlaWdodCwgYm9yZGVyLCBmb3JtYXQsIHR5cGUsIGJ1ZmZlci5nZXQoKSk7CiAgICAgfQot ICAgIHJldHVybiB0ZXhJbWFnZTJEKHRhcmdldCwgbGV2ZWwsIGludGVybmFsZm9ybWF0LCB3aWR0 aCwgaGVpZ2h0LCBib3JkZXIsIGZvcm1hdCwgdHlwZSwgemVyby5nZXQoKSk7CisKKyAgICBzeW50 aGVzaXplR0xFcnJvcihlcnJvcik7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIEdyYXBo aWNzQ29udGV4dDNEOjp0ZXhJbWFnZTJEUmVzb3VyY2VTYWZlTm9DbGVhcihHQzNEZW51bSB0YXJn ZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVtIGludGVybmFsZm9ybWF0LCBHQzNEc2l6ZWkgd2lk dGgsIEdDM0RzaXplaSBoZWlnaHQsIEdDM0RpbnQgYm9yZGVyLCBHQzNEZW51bSBmb3JtYXQsIEdD M0RlbnVtIHR5cGUsIEdDM0RpbnQgdW5wYWNrQWxpZ25tZW50KQoreworICAgIE93bkFycmF5UHRy PHVuc2lnbmVkIGNoYXI+IGJ1ZmZlcjsKKyAgICB1bnNpZ25lZCBpbnQgc2l6ZTsKKyAgICBHQzNE ZW51bSBlcnJvciA9IGFsbG9jYXRlVGV4SW1hZ2UyREJ1ZmZlcigmYnVmZmVyLCAmc2l6ZSwgdGhp cywgd2lkdGgsIGhlaWdodCwgZm9ybWF0LCB0eXBlLCB1bnBhY2tBbGlnbm1lbnQpOworICAgIGlm IChHcmFwaGljc0NvbnRleHQzRDo6Tk9fRVJST1IgPT0gZXJyb3IpCisgICAgICAgIHJldHVybiB0 ZXhJbWFnZTJEKHRhcmdldCwgbGV2ZWwsIGludGVybmFsZm9ybWF0LCB3aWR0aCwgaGVpZ2h0LCBi b3JkZXIsIGZvcm1hdCwgdHlwZSwgYnVmZmVyLmdldCgpKTsKKworICAgIHN5bnRoZXNpemVHTEVy cm9yKGVycm9yKTsKKyAgICByZXR1cm4gZmFsc2U7CiB9CiAKIGJvb2wgR3JhcGhpY3NDb250ZXh0 M0Q6OmNvbXB1dGVGb3JtYXRBbmRUeXBlUGFyYW1ldGVycyhHQzNEZW51bSBmb3JtYXQsCkluZGV4 OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQzRC5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29u dGV4dDNELmgJKHJldmlzaW9uIDgyNzA2KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvR3JhcGhpY3NDb250ZXh0M0QuaAkod29ya2luZyBjb3B5KQpAQCAtNDgyLDEwICs0ODIs MTUgQEAgcHVibGljOgogI2VuZGlmCiAKICAgICAvLyBIZWxwZXIgdG8gdGV4SW1hZ2UyRCB3aXRo IHBpeGVsPT0wIGNhc2U6IHBpeGVscyBhcmUgaW5pdGlhbGl6ZWQgdG8gMC4KLSAgICAvLyBSZXR1 cm4gdHJ1ZSBpZiBubyBHTCBlcnJvciBpcyBzeW50aGVzaXplZC4KKyAgICAvLyBSZXR1cm5zIHRy dWUgaWYgbm8gR0wgZXJyb3IgaXMgc3ludGhlc2l6ZWQuCiAgICAgLy8gQnkgZGVmYXVsdCwgYWxp Z25tZW50IGlzIDQsIHRoZSBPcGVuR0wgZGVmYXVsdCBzZXR0aW5nLgogICAgIGJvb2wgdGV4SW1h Z2UyRFJlc291cmNlU2FmZShHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVt IGludGVybmFsZm9ybWF0LCBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQsIEdDM0Rp bnQgYm9yZGVyLCBHQzNEZW51bSBmb3JtYXQsIEdDM0RlbnVtIHR5cGUsIEdDM0RpbnQgYWxpZ25t ZW50ID0gNCk7CiAKKyAgICAvLyBIZWxwZXIgdG8gdGV4SW1hZ2UyRC4gUGVyZm9ybXMgc29tZSBz YWZldHkgY2hlY2tzIG9uIHRoZSBzaXplIG9mIHRoZQorICAgIC8vIHJlcXVlc3RlZCB0ZXh0dXJl LiBEb2VzIG5vdCBpbml0aWFsaXplIGFsbCBvZiB0aGUgcGl4ZWxzIHRvIDAuCisgICAgLy8gUmV0 dXJucyB0cnVlIGlmIG5vIEdMIGVycm9yIGlzIHN5bnRoZXNpemVkLgorICAgIGJvb2wgdGV4SW1h Z2UyRFJlc291cmNlU2FmZU5vQ2xlYXIoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBH QzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0 LCBHQzNEaW50IGJvcmRlciwgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLCBHQzNEaW50 IGFsaWdubWVudCA9IDQpOworCiAgICAgYm9vbCBpc0dMRVMyQ29tcGxpYW50KCkgY29uc3Q7CiAK ICAgICAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2dwdS9EcmF3aW5nQnVmZmVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1ZmZlci5jcHAJKHJldmlzaW9uIDgyNzA2KQor KysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0RyYXdpbmdCdWZmZXIuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0xNDQsMTUgKzE0NCwyMiBAQCB2b2lkIERyYXdpbmdCdWZmZXI6 OnJlc2l6ZURlcHRoU3RlbmNpbChpCiAgICAgbV9jb250ZXh0LT5iaW5kUmVuZGVyYnVmZmVyKEdy YXBoaWNzQ29udGV4dDNEOjpSRU5ERVJCVUZGRVIsIDApOwogfQogCi12b2lkIERyYXdpbmdCdWZm ZXI6OnJlc2V0KGNvbnN0IEludFNpemUmIG5ld1NpemUpCitib29sIERyYXdpbmdCdWZmZXI6OnJl c2V0KGNvbnN0IEludFNpemUmIG5ld1NpemUpCiB7Ci0gICAgbV9zaXplID0gbmV3U2l6ZTsKLQog ICAgIGlmICghbV9jb250ZXh0KQotICAgICAgICByZXR1cm47Ci0gICAgICAgIAorICAgICAgICBy ZXR1cm4gZmFsc2U7CisKICAgICBtX2NvbnRleHQtPm1ha2VDb250ZXh0Q3VycmVudCgpOwotICAg IAorCisgICAgaW50IG1heFRleHR1cmVTaXplID0gMDsKKyAgICBtX2NvbnRleHQtPmdldEludGVn ZXJ2KEdyYXBoaWNzQ29udGV4dDNEOjpNQVhfVEVYVFVSRV9TSVpFLCAmbWF4VGV4dHVyZVNpemUp OworICAgIGlmIChuZXdTaXplLmhlaWdodCgpID4gbWF4VGV4dHVyZVNpemUgfHwgbmV3U2l6ZS53 aWR0aCgpID4gbWF4VGV4dHVyZVNpemUpIHsKKyAgICAgIGNsZWFyKCk7CisgICAgICByZXR1cm4g ZmFsc2U7CisgICAgfQorCisgICAgbV9zaXplID0gbmV3U2l6ZTsKKwogICAgIGNvbnN0IEdyYXBo aWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzJiBhdHRyaWJ1dGVzID0gbV9jb250ZXh0LT5nZXRDb250 ZXh0QXR0cmlidXRlcygpOwogICAgIHVuc2lnbmVkIGxvbmcgaW50ZXJuYWxDb2xvckZvcm1hdCwg Y29sb3JGb3JtYXQsIGludGVybmFsUmVuZGVyYnVmZmVyRm9ybWF0OwogICAgIGlmIChhdHRyaWJ1 dGVzLmFscGhhKSB7CkBAIC0xODIsNyArMTg5LDcgQEAgdm9pZCBEcmF3aW5nQnVmZmVyOjpyZXNl dChjb25zdCBJbnRTaXplJgogICAgICAgICBpZiAobV9jb250ZXh0LT5jaGVja0ZyYW1lYnVmZmVy U3RhdHVzKEdyYXBoaWNzQ29udGV4dDNEOjpGUkFNRUJVRkZFUikgIT0gR3JhcGhpY3NDb250ZXh0 M0Q6OkZSQU1FQlVGRkVSX0NPTVBMRVRFKSB7CiAgICAgICAgICAgICAvLyBDbGVhbnVwCiAgICAg ICAgICAgICBjbGVhcigpOwotICAgICAgICAgICAgcmV0dXJuOworICAgICAgICAgICAgcmV0dXJu IGZhbHNlOwogICAgICAgICB9CiAgICAgfQogCkBAIC0xOTAsMjEgKzE5NywyOCBAQCB2b2lkIERy YXdpbmdCdWZmZXI6OnJlc2V0KGNvbnN0IEludFNpemUmCiAgICAgbV9jb250ZXh0LT5iaW5kRnJh bWVidWZmZXIoR3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSLCBtX2Zibyk7CiAKICAgICBt X2NvbnRleHQtPmJpbmRUZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBtX2Nv bG9yQnVmZmVyKTsKLSAgICBtX2NvbnRleHQtPnRleEltYWdlMkRSZXNvdXJjZVNhZmUoR3JhcGhp Y3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQsIDAsIGludGVybmFsQ29sb3JGb3JtYXQsIG1fc2l6ZS53 aWR0aCgpLCBtX3NpemUuaGVpZ2h0KCksIDAsIGNvbG9yRm9ybWF0LCBHcmFwaGljc0NvbnRleHQz RDo6VU5TSUdORURfQllURSk7CisgICAgCisgICAgYm9vbCByZXNvdXJjZVNhZmUgPSBtX2NvbnRl eHQtPmdldEV4dGVuc2lvbnMoKS0+c3VwcG9ydHMoIkdMX0NIUk9NSVVNX3Jlc291cmNlX3NhZmUi KTsKKyAgICBpZiAoIXJlc291cmNlU2FmZSkKKyAgICAgICAgbV9jb250ZXh0LT50ZXhJbWFnZTJE UmVzb3VyY2VTYWZlKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCAwLCBpbnRlcm5hbENv bG9yRm9ybWF0LCBtX3NpemUud2lkdGgoKSwgbV9zaXplLmhlaWdodCgpLCAwLCBjb2xvckZvcm1h dCwgR3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZVEUpOworICAgIGVsc2UKKyAgICAgICAg bV9jb250ZXh0LT50ZXhJbWFnZTJEUmVzb3VyY2VTYWZlTm9DbGVhcihHcmFwaGljc0NvbnRleHQz RDo6VEVYVFVSRV8yRCwgMCwgaW50ZXJuYWxDb2xvckZvcm1hdCwgbV9zaXplLndpZHRoKCksIG1f c2l6ZS5oZWlnaHQoKSwgMCwgY29sb3JGb3JtYXQsIEdyYXBoaWNzQ29udGV4dDNEOjpVTlNJR05F RF9CWVRFKTsKKwogICAgIG1fY29udGV4dC0+ZnJhbWVidWZmZXJUZXh0dXJlMkQoR3JhcGhpY3ND b250ZXh0M0Q6OkZSQU1FQlVGRkVSLCBHcmFwaGljc0NvbnRleHQzRDo6Q09MT1JfQVRUQUNITUVO VDAsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBtX2NvbG9yQnVmZmVyLCAwKTsKICAg ICBtX2NvbnRleHQtPmJpbmRUZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCAw KTsKKwogICAgIGlmICghbXVsdGlzYW1wbGUoKSkKICAgICAgICAgcmVzaXplRGVwdGhTdGVuY2ls KDApOwogICAgIGlmIChtX2NvbnRleHQtPmNoZWNrRnJhbWVidWZmZXJTdGF0dXMoR3JhcGhpY3ND b250ZXh0M0Q6OkZSQU1FQlVGRkVSKSAhPSBHcmFwaGljc0NvbnRleHQzRDo6RlJBTUVCVUZGRVJf Q09NUExFVEUpIHsKICAgICAgICAgLy8gQ2xlYW51cAogICAgICAgICBjbGVhcigpOwotICAgICAg ICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKICAgICBpZiAobXVsdGlz YW1wbGUoKSkKICAgICAgICAgbV9jb250ZXh0LT5iaW5kRnJhbWVidWZmZXIoR3JhcGhpY3NDb250 ZXh0M0Q6OkZSQU1FQlVGRkVSLCBtX211bHRpc2FtcGxlRkJPKTsKIAotICAgIGlmICghbV9jb250 ZXh0LT5nZXRFeHRlbnNpb25zKCktPnN1cHBvcnRzKCJHTF9DSFJPTUlVTV9yZXNvdXJjZV9zYWZl IikpIHsKKyAgICBpZiAoIXJlc291cmNlU2FmZSkgewogICAgICAgICAvLyBJbml0aWFsaXplIHJl bmRlcmJ1ZmZlcnMgKGRlcHRoL3N0ZW5jaWwpLgogICAgICAgICBmbG9hdCBjbGVhckRlcHRoID0g MDsKICAgICAgICAgaW50IGNsZWFyU3RlbmNpbCA9IDA7CkBAIC0yNTAsNiArMjY0LDggQEAgdm9p ZCBEcmF3aW5nQnVmZmVyOjpyZXNldChjb25zdCBJbnRTaXplJgogICAgIG1fY29udGV4dC0+Zmx1 c2goKTsKICAgICAKICAgICBkaWRSZXNldCgpOworCisgICAgcmV0dXJuIHRydWU7CiB9CiAKIHZv aWQgRHJhd2luZ0J1ZmZlcjo6Y29tbWl0KGxvbmcgeCwgbG9uZyB5LCBsb25nIHdpZHRoLCBsb25n IGhlaWdodCkKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9EcmF3 aW5nQnVmZmVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvZ3B1L0RyYXdpbmdCdWZmZXIuaAkocmV2aXNpb24gODI3MDYpCisrKyBTb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1ZmZlci5oCSh3b3JraW5nIGNvcHkpCkBA IC02MCw3ICs2MCw4IEBAIHB1YmxpYzoKICAgICAKICAgICB+RHJhd2luZ0J1ZmZlcigpOwogCi0g ICAgdm9pZCByZXNldChjb25zdCBJbnRTaXplJik7CisgICAgLy8gUmV0dXJucyB0cnVlIGlmIHRo ZSBidWZmZXIgd2FzIHN1Y2Nlc3NmdWxseSByZXNpemVkLgorICAgIGJvb2wgcmVzZXQoY29uc3Qg SW50U2l6ZSYpOwogICAgIHZvaWQgYmluZCgpOwogICAgIEludFNpemUgc2l6ZSgpIGNvbnN0IHsg cmV0dXJuIG1fc2l6ZTsgfQogICAgIFBsYXRmb3JtM0RPYmplY3QgY29sb3JCdWZmZXIoKSBjb25z dCB7IHJldHVybiBtX2NvbG9yQnVmZmVyOyB9CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA4MzEzMCkKKysr IExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDEzIEBACisy MDExLTA0LTA2ICBKZWZmIFRpbWFudXMgIDx0d2l6QGNocm9taXVtLm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBGYWxsIGJhY2sgdG8gc29mdHdh cmUgcmVuZGVyaW5nIGZvciBDYW52YXMyRCB3aGVuIHJlcXVlc3RpbmcgYSBEcmF3aW5nQnVmZmVy IGxhcmdlciB0aGFuIHN1cHBvcnRlZCBieSB0aGUgR0wgZW52aXJvbm1lbnQuCisgICAgICAgIEFs c28sIHJlc3BlY3QgdGhlIGNvbnRyYWN0IHByb3ZpZGVkIGJ5IGV4dGVuc2lvbiAiR0xfQ0hST01J VU1fcmVzb3VyY2Vfc2FmZSIgd2hlbiByZXF1ZXN0aW5nIHRleHR1cmVzIGZvciBGQk9zIGZvciBE cmF3aW5nQnVmZmVyIGluc3RhbmNlcy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTU3NzY4CisKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS90ZXN0 X2V4cGVjdGF0aW9ucy50eHQ6CisKIDIwMTEtMDQtMDYgIERhbiBCZXJuc3RlaW4gIDxtaXR6QGFw cGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KSW5kZXg6IExheW91 dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQJ KHJldmlzaW9uIDgyNzA2KQorKysgTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vdGVzdF9l eHBlY3RhdGlvbnMudHh0CSh3b3JraW5nIGNvcHkpCkBAIC0yOTMwLDkgKzI5MzAsNiBAQCBCVUdD UjYwOTY1IEdQVSBXSU4gTElOVVggOiBmYXN0L2NhbnZhcy9zCiAKIEJVR05PTkUgU0xPVyBHUFUg REVCVUcgV0lOIDogZmFzdC9jYW52YXMvY2FudmFzLWdldEltYWdlRGF0YS5odG1sID0gUEFTUwog Ci0vLyBTdGFydGVkIGZhaWxpbmcgYWZ0ZXIgcjc1NjQ4IG9uIGV2ZXJ5dGhpbmcgZXhjZXB0IFNu b3cgTGVvcGFyZAotQlVHV0s1MjM0MSBHUFUgOiBmYXN0L2NhbnZhcy9jYW52YXMtbGFyZ2UtZGlt ZW5zaW9ucy5odG1sID0gVEVYVAotCiBCVUdXSzUzNDY5IEdQVSBNQUMgOiBjb21wb3NpdGluZy9z Y3JvbGwtcGFpbnRlZC1jb21wb3NpdGVkLWNvbnRlbnQuaHRtbCA9IENSQVNICiAKIEJVR0NSNzQ5 NzkgR1BVIE1BQzogbWVkaWEvdmlkZW8tY2FudmFzLWFscGhhLmh0bWwgPSBJTUFHRQo= 88842 2011-04-08 10:56:59 -0700 2011-04-08 16:01:52 -0700 Patch bug-57768-20110408135441.patch text/plain 7769 twiz SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDgzMzEyKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDQtMDggIEplZmYgVGlt YW51cyAgPHR3aXpAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEZhbGwgYmFjayB0byBzb2Z0d2FyZSByZW5kZXJpbmcgZm9yIENh bnZhczJEIHdoZW4gcmVxdWVzdGluZyBhIERyYXdpbmdCdWZmZXIgbGFyZ2VyIHRoYW4gc3VwcG9y dGVkIGJ5IHRoZSBHTCBlbnZpcm9ubWVudC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTU3NzY4CisKKyAgICAgICAgKiBodG1sL2NhbnZhcy9DYW52YXNS ZW5kZXJpbmdDb250ZXh0MkQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q2FudmFzUmVuZGVyaW5n Q29udGV4dDJEOjpDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQpOgorICAgICAgICAoV2ViQ29yZTo6 Q2FudmFzUmVuZGVyaW5nQ29udGV4dDJEOjpyZXNldCk6CisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvZ3B1L0RyYXdpbmdCdWZmZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RHJhd2luZ0J1 ZmZlcjo6cmVzZXQpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9EcmF3aW5nQnVm ZmVyLmg6CisKIDIwMTEtMDQtMDggIEFiaGlzaGVrIEFyeWEgIDxpbmZlcm5vQGNocm9taXVtLm9y Zz4KIAogICAgICAgICBVbnJldmlld2VkLiBSZW1vdmUgYWNjaWRlbnRhbCBwcmludGYgYWRkZWQg aW4gcjgzMzA2LgpJbmRleDogU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvQ2FudmFzUmVuZGVy aW5nQ29udGV4dDJELmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZh cy9DYW52YXNSZW5kZXJpbmdDb250ZXh0MkQuY3BwCShyZXZpc2lvbiA4MzIzNykKKysrIFNvdXJj ZS9XZWJDb3JlL2h0bWwvY2FudmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTEzMyw3ICsxMzMsMTEgQEAgQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJEOjpD YW52YXNSZW5kZXJpbgogICAgICAgICBtX2NvbnRleHQzRCA9IHAtPnNoYXJlZEdyYXBoaWNzQ29u dGV4dDNEKCk7CiAgICAgICAgIGlmIChtX2NvbnRleHQzRCkgewogICAgICAgICAgICAgbV9kcmF3 aW5nQnVmZmVyID0gbV9jb250ZXh0M0QtPmdyYXBoaWNzQ29udGV4dDNEKCktPmNyZWF0ZURyYXdp bmdCdWZmZXIoSW50U2l6ZShjYW52YXMtPndpZHRoKCksIGNhbnZhcy0+aGVpZ2h0KCkpKTsKLSAg ICAgICAgICAgIGMtPnNldFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEKG1fY29udGV4dDNELmdldCgp LCBtX2RyYXdpbmdCdWZmZXIuZ2V0KCksIEludFNpemUoY2FudmFzLT53aWR0aCgpLCBjYW52YXMt PmhlaWdodCgpKSk7CisgICAgICAgICAgICBpZiAoIW1fZHJhd2luZ0J1ZmZlcikgeworICAgICAg ICAgICAgICAgIGMtPnNldFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEKDAsIDAsIEludFNpemUoKSk7 CisgICAgICAgICAgICAgICAgbV9jb250ZXh0M0QuY2xlYXIoKTsKKyAgICAgICAgICAgIH0gZWxz ZQorICAgICAgICAgICAgICAgIGMtPnNldFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEKG1fY29udGV4 dDNELmdldCgpLCBtX2RyYXdpbmdCdWZmZXIuZ2V0KCksIEludFNpemUoY2FudmFzLT53aWR0aCgp LCBjYW52YXMtPmhlaWdodCgpKSk7CiAgICAgICAgIH0KICAgICB9CiAjZW5kaWYKQEAgLTE3Mywx MyArMTc3LDE4IEBAIHZvaWQgQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJEOjpyZXNldCgpCiAjaWYg RU5BQkxFKEFDQ0VMRVJBVEVEXzJEX0NBTlZBUykKICAgICBpZiAoR3JhcGhpY3NDb250ZXh0KiBj ID0gZHJhd2luZ0NvbnRleHQoKSkgewogICAgICAgICBpZiAobV9jb250ZXh0M0QgJiYgbV9kcmF3 aW5nQnVmZmVyKSB7Ci0gICAgICAgICAgICBtX2RyYXdpbmdCdWZmZXItPnJlc2V0KEludFNpemUo Y2FudmFzKCktPndpZHRoKCksIGNhbnZhcygpLT5oZWlnaHQoKSkpOwotICAgICAgICAgICAgYy0+ c2V0U2hhcmVkR3JhcGhpY3NDb250ZXh0M0QobV9jb250ZXh0M0QuZ2V0KCksIG1fZHJhd2luZ0J1 ZmZlci5nZXQoKSwgSW50U2l6ZShjYW52YXMoKS0+d2lkdGgoKSwgY2FudmFzKCktPmhlaWdodCgp KSk7CisgICAgICAgICAgICBpZiAobV9kcmF3aW5nQnVmZmVyLT5yZXNldChJbnRTaXplKGNhbnZh cygpLT53aWR0aCgpLCBjYW52YXMoKS0+aGVpZ2h0KCkpKSkgeworICAgICAgICAgICAgICAgIGMt PnNldFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEKG1fY29udGV4dDNELmdldCgpLCBtX2RyYXdpbmdC dWZmZXIuZ2V0KCksIEludFNpemUoY2FudmFzKCktPndpZHRoKCksIGNhbnZhcygpLT5oZWlnaHQo KSkpOwogI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKLSAgICAgICAgICAgIFJlbmRl ckJveCogcmVuZGVyQm94ID0gY2FudmFzKCktPnJlbmRlckJveCgpOwotICAgICAgICAgICAgaWYg KHJlbmRlckJveCAmJiByZW5kZXJCb3gtPmhhc0xheWVyKCkgJiYgcmVuZGVyQm94LT5sYXllcigp LT5oYXNBY2NlbGVyYXRlZENvbXBvc2l0aW5nKCkpCi0gICAgICAgICAgICAgICAgcmVuZGVyQm94 LT5sYXllcigpLT5jb250ZW50Q2hhbmdlZChSZW5kZXJMYXllcjo6Q2FudmFzQ2hhbmdlZCk7Cisg ICAgICAgICAgICAgICAgUmVuZGVyQm94KiByZW5kZXJCb3ggPSBjYW52YXMoKS0+cmVuZGVyQm94 KCk7CisgICAgICAgICAgICAgICAgaWYgKHJlbmRlckJveCAmJiByZW5kZXJCb3gtPmhhc0xheWVy KCkgJiYgcmVuZGVyQm94LT5sYXllcigpLT5oYXNBY2NlbGVyYXRlZENvbXBvc2l0aW5nKCkpCisg ICAgICAgICAgICAgICAgICAgIHJlbmRlckJveC0+bGF5ZXIoKS0+Y29udGVudENoYW5nZWQoUmVu ZGVyTGF5ZXI6OkNhbnZhc0NoYW5nZWQpOwogI2VuZGlmCisgICAgICAgICAgICB9IGVsc2Ugewor ICAgICAgICAgICAgICAgIGMtPnNldFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEKDAsIDAsIEludFNp emUoKSk7CisgICAgICAgICAgICAgICAgbV9kcmF3aW5nQnVmZmVyLmNsZWFyKCk7CisgICAgICAg ICAgICAgICAgbV9jb250ZXh0M0QuY2xlYXIoKTsKKyAgICAgICAgICAgIH0KICAgICAgICAgfQog ICAgIH0KICNlbmRpZgpJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1 L0RyYXdpbmdCdWZmZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2dwdS9EcmF3aW5nQnVmZmVyLmNwcAkocmV2aXNpb24gODMyMzcpCisrKyBTb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1ZmZlci5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTE0NCwxNSArMTQ0LDIyIEBAIHZvaWQgRHJhd2luZ0J1ZmZlcjo6cmVzaXpl RGVwdGhTdGVuY2lsKGkKICAgICBtX2NvbnRleHQtPmJpbmRSZW5kZXJidWZmZXIoR3JhcGhpY3ND b250ZXh0M0Q6OlJFTkRFUkJVRkZFUiwgMCk7CiB9CiAKLXZvaWQgRHJhd2luZ0J1ZmZlcjo6cmVz ZXQoY29uc3QgSW50U2l6ZSYgbmV3U2l6ZSkKK2Jvb2wgRHJhd2luZ0J1ZmZlcjo6cmVzZXQoY29u c3QgSW50U2l6ZSYgbmV3U2l6ZSkKIHsKLSAgICBtX3NpemUgPSBuZXdTaXplOwotCiAgICAgaWYg KCFtX2NvbnRleHQpCi0gICAgICAgIHJldHVybjsKLSAgICAgICAgCisgICAgICAgIHJldHVybiBm YWxzZTsKKwogICAgIG1fY29udGV4dC0+bWFrZUNvbnRleHRDdXJyZW50KCk7Ci0gICAgCisKKyAg ICBpbnQgbWF4VGV4dHVyZVNpemUgPSAwOworICAgIG1fY29udGV4dC0+Z2V0SW50ZWdlcnYoR3Jh cGhpY3NDb250ZXh0M0Q6Ok1BWF9URVhUVVJFX1NJWkUsICZtYXhUZXh0dXJlU2l6ZSk7CisgICAg aWYgKG5ld1NpemUuaGVpZ2h0KCkgPiBtYXhUZXh0dXJlU2l6ZSB8fCBuZXdTaXplLndpZHRoKCkg PiBtYXhUZXh0dXJlU2l6ZSkgeworICAgICAgY2xlYXIoKTsKKyAgICAgIHJldHVybiBmYWxzZTsK KyAgICB9CisKKyAgICBtX3NpemUgPSBuZXdTaXplOworCiAgICAgY29uc3QgR3JhcGhpY3NDb250 ZXh0M0Q6OkF0dHJpYnV0ZXMmIGF0dHJpYnV0ZXMgPSBtX2NvbnRleHQtPmdldENvbnRleHRBdHRy aWJ1dGVzKCk7CiAgICAgdW5zaWduZWQgbG9uZyBpbnRlcm5hbENvbG9yRm9ybWF0LCBjb2xvckZv cm1hdCwgaW50ZXJuYWxSZW5kZXJidWZmZXJGb3JtYXQ7CiAgICAgaWYgKGF0dHJpYnV0ZXMuYWxw aGEpIHsKQEAgLTE4Miw3ICsxODksNyBAQCB2b2lkIERyYXdpbmdCdWZmZXI6OnJlc2V0KGNvbnN0 IEludFNpemUmCiAgICAgICAgIGlmIChtX2NvbnRleHQtPmNoZWNrRnJhbWVidWZmZXJTdGF0dXMo R3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSKSAhPSBHcmFwaGljc0NvbnRleHQzRDo6RlJB TUVCVUZGRVJfQ09NUExFVEUpIHsKICAgICAgICAgICAgIC8vIENsZWFudXAKICAgICAgICAgICAg IGNsZWFyKCk7Ci0gICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICByZXR1cm4gZmFsc2U7 CiAgICAgICAgIH0KICAgICB9CiAKQEAgLTE5MCwxNSArMTk3LDE4IEBAIHZvaWQgRHJhd2luZ0J1 ZmZlcjo6cmVzZXQoY29uc3QgSW50U2l6ZSYKICAgICBtX2NvbnRleHQtPmJpbmRGcmFtZWJ1ZmZl cihHcmFwaGljc0NvbnRleHQzRDo6RlJBTUVCVUZGRVIsIG1fZmJvKTsKIAogICAgIG1fY29udGV4 dC0+YmluZFRleHR1cmUoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQsIG1fY29sb3JCdWZm ZXIpOworICAgIAogICAgIG1fY29udGV4dC0+dGV4SW1hZ2UyRFJlc291cmNlU2FmZShHcmFwaGlj c0NvbnRleHQzRDo6VEVYVFVSRV8yRCwgMCwgaW50ZXJuYWxDb2xvckZvcm1hdCwgbV9zaXplLndp ZHRoKCksIG1fc2l6ZS5oZWlnaHQoKSwgMCwgY29sb3JGb3JtYXQsIEdyYXBoaWNzQ29udGV4dDNE OjpVTlNJR05FRF9CWVRFKTsKKwogICAgIG1fY29udGV4dC0+ZnJhbWVidWZmZXJUZXh0dXJlMkQo R3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSLCBHcmFwaGljc0NvbnRleHQzRDo6Q09MT1Jf QVRUQUNITUVOVDAsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBtX2NvbG9yQnVmZmVy LCAwKTsKICAgICBtX2NvbnRleHQtPmJpbmRUZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEOjpURVhU VVJFXzJELCAwKTsKKwogICAgIGlmICghbXVsdGlzYW1wbGUoKSkKICAgICAgICAgcmVzaXplRGVw dGhTdGVuY2lsKDApOwogICAgIGlmIChtX2NvbnRleHQtPmNoZWNrRnJhbWVidWZmZXJTdGF0dXMo R3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSKSAhPSBHcmFwaGljc0NvbnRleHQzRDo6RlJB TUVCVUZGRVJfQ09NUExFVEUpIHsKICAgICAgICAgLy8gQ2xlYW51cAogICAgICAgICBjbGVhcigp OwotICAgICAgICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKICAgICBp ZiAobXVsdGlzYW1wbGUoKSkKQEAgLTI1MCw2ICsyNjAsOCBAQCB2b2lkIERyYXdpbmdCdWZmZXI6 OnJlc2V0KGNvbnN0IEludFNpemUmCiAgICAgbV9jb250ZXh0LT5mbHVzaCgpOwogICAgIAogICAg IGRpZFJlc2V0KCk7CisKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAogdm9pZCBEcmF3aW5nQnVmZmVy Ojpjb21taXQobG9uZyB4LCBsb25nIHksIGxvbmcgd2lkdGgsIGxvbmcgaGVpZ2h0KQpJbmRleDog U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0RyYXdpbmdCdWZmZXIuaAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1 ZmZlci5oCShyZXZpc2lvbiA4MzIzNykKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2dwdS9EcmF3aW5nQnVmZmVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTYwLDcgKzYwLDggQEAg cHVibGljOgogICAgIAogICAgIH5EcmF3aW5nQnVmZmVyKCk7CiAKLSAgICB2b2lkIHJlc2V0KGNv bnN0IEludFNpemUmKTsKKyAgICAvLyBSZXR1cm5zIHRydWUgaWYgdGhlIGJ1ZmZlciB3YXMgc3Vj Y2Vzc2Z1bGx5IHJlc2l6ZWQuCisgICAgYm9vbCByZXNldChjb25zdCBJbnRTaXplJik7CiAgICAg dm9pZCBiaW5kKCk7CiAgICAgSW50U2l6ZSBzaXplKCkgY29uc3QgeyByZXR1cm4gbV9zaXplOyB9 CiAgICAgUGxhdGZvcm0zRE9iamVjdCBjb2xvckJ1ZmZlcigpIGNvbnN0IHsgcmV0dXJuIG1fY29s b3JCdWZmZXI7IH0KSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBM YXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDgzMzEyKQorKysgTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTIgQEAKKzIwMTEtMDQtMDggIEplZmYg VGltYW51cyAgPHR3aXpAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIEZhbGwgYmFjayB0byBzb2Z0d2FyZSByZW5kZXJpbmcgZm9y IENhbnZhczJEIHdoZW4gcmVxdWVzdGluZyBhIERyYXdpbmdCdWZmZXIgbGFyZ2VyIHRoYW4gc3Vw cG9ydGVkIGJ5IHRoZSBHTCBlbnZpcm9ubWVudC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTU3NzY4CisKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1 bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQ6CisKIDIwMTEtMDQtMDggIFNoZXJpZmYgQm90ICA8d2Vi a2l0LnJldmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcg b3V0IHI4MzI5NS4KSW5kZXg6IExheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL3Rlc3RfZXhw ZWN0YXRpb25zLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1 bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQJKHJldmlzaW9uIDgzMjM3KQorKysgTGF5b3V0VGVzdHMv cGxhdGZvcm0vY2hyb21pdW0vdGVzdF9leHBlY3RhdGlvbnMudHh0CSh3b3JraW5nIGNvcHkpCkBA IC0yOTE4LDkgKzI5MTgsNiBAQCBCVUdDUjYwOTY1IEdQVSBXSU4gTElOVVggOiBmYXN0L2NhbnZh cy9zCiAKIEJVR05PTkUgU0xPVyBHUFUgREVCVUcgV0lOIDogZmFzdC9jYW52YXMvY2FudmFzLWdl dEltYWdlRGF0YS5odG1sID0gUEFTUwogCi0vLyBTdGFydGVkIGZhaWxpbmcgYWZ0ZXIgcjc1NjQ4 IG9uIGV2ZXJ5dGhpbmcgZXhjZXB0IFNub3cgTGVvcGFyZAotQlVHV0s1MjM0MSBHUFUgOiBmYXN0 L2NhbnZhcy9jYW52YXMtbGFyZ2UtZGltZW5zaW9ucy5odG1sID0gVEVYVAotCiBCVUdXSzUzNDY5 IEdQVSBNQUMgOiBjb21wb3NpdGluZy9zY3JvbGwtcGFpbnRlZC1jb21wb3NpdGVkLWNvbnRlbnQu aHRtbCA9IENSQVNICiAKIEJVR0NSNzQ5NzkgR1BVIE1BQzogbWVkaWEvdmlkZW8tY2FudmFzLWFs cGhhLmh0bWwgPSBJTUFHRQo=