44127 2010-08-17 13:33:28 -0700 [chromium] Thumbnails not generated for GPU Rendered Pages 2010-09-13 23:51:00 -0700 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 0 wjmaclean webkit-unassigned abarth commit-queue eric fishd levin vangelis webkit.review.bot oldest_to_newest 265733 0 wjmaclean 2010-08-17 13:33:28 -0700 When running chrome with --enable-accelerated-compositing, page thumbnails are not generated for pages rendered on the GPU. 265739 1 64625 wjmaclean 2010-08-17 13:49:52 -0700 Created attachment 64625 Patch to allow pixel readback from GPU for thumbnail generation. Patch to allow pixel readback from GPU for thumbnail generation. 265744 2 webkit.review.bot 2010-08-17 13:52:05 -0700 Attachment 64625 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:512: Extra space before last semicolon. If this should be an empty statement, use { } instead. [whitespace/semicolon] [5] WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:528: Missing spaces around / [whitespace/operators] [3] WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:529: This { should be at the end of the previous line [whitespace/braces] [4] Total errors found: 3 in 7 files If any of these errors are false positives, please file a bug against check-webkit-style. 265749 3 64628 wjmaclean 2010-08-17 13:57:11 -0700 Created attachment 64628 Patch to allow pixel readback from GPU for thumbnail generation. Fixes style errors from previous patch. 265755 4 webkit.review.bot 2010-08-17 13:59:24 -0700 Attachment 64628 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:528: Missing space before { [whitespace/braces] [5] Total errors found: 1 in 7 files If any of these errors are false positives, please file a bug against check-webkit-style. 265813 5 64628 vangelis 2010-08-17 15:51:45 -0700 Comment on attachment 64628 Patch to allow pixel readback from GPU for thumbnail generation. > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index ad3ea90..6854b00 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,16 @@ > +2010-08-17 W. James MacLean <wjmaclean@google.com> > + > + Reviewed by NOBODY (OOPS!). > + > + [chromium] Thumbnails not generated for GPU Rendered Pages > + https://bugs.webkit.org/show_bug.cgi?id=44127 > + > + Added functions to allow readback of GPU buffer for generating Chromium thumbnails. > + > + * platform/graphics/chromium/LayerRendererChromium.cpp: > + (WebCore::LayerRendererChromium::readPixels): > + * platform/graphics/chromium/LayerRendererChromium.h: > + > 2010-08-17 Darin Fisher <darin@chromium.org> > > Reviewed by Darin Adler. > diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > index 2f70efa..b73ae86 100644 > --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > @@ -506,6 +506,36 @@ void LayerRendererChromium::drawLayers(const IntRect& updateRect, const IntRect& > m_needsDisplay = false; > } > > +void LayerRendererChromium::readPixels(skia::PlatformCanvas* canvasPtr) > +{ > + if (!canvasPtr) > + return; > + > + makeContextCurrent(); > + > + checkGLError(); > + > + const SkBitmap bitmap = canvasPtr->getDevice()->accessBitmap(false); > + void* pixels = bitmap.getPixels(); > + > + glReadPixels(0, 0, bitmap.width(), bitmap.height(), > + GL_RGBA, GL_UNSIGNED_BYTE, pixels); > + > + checkGLError(); > + > + // Flip pixels vertically ... > + OwnPtr<unsigned char> lineTemp(new unsigned char[bitmap.rowBytes()]); > + for (int row1 = 0, row2 = bitmap.height() - 1; row1 < bitmap.height() / 2; ++row1, --row2){ > + unsigned char *ptr1 = static_cast<unsigned char *>(pixels) + row1 * bitmap.rowBytes(); > + unsigned char *ptr2 = static_cast<unsigned char *>(pixels) + row2 * bitmap.rowBytes(); > + > + memcpy(lineTemp.get(), ptr1, bitmap.rowBytes()); > + memcpy(ptr1, ptr2, bitmap.rowBytes()); > + memcpy(ptr2, lineTemp.get(), bitmap.rowBytes()); > + } > +} > + > + > // Returns the id of the texture currently associated with the layer or > // -1 if the id hasn't been registered yet. > int LayerRendererChromium::getTextureId(LayerChromium* layer) > diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.h b/WebCore/platform/graphics/chromium/LayerRendererChromium.h > index e4474b5..0a20ca3 100644 > --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.h > +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.h > @@ -87,6 +87,8 @@ public: > > GraphicsContext* rootLayerGraphicsContext() const { return m_rootLayerGraphicsContext.get(); } > > + void readPixels(skia::PlatformCanvas* canvasPtr); > + > private: > enum ShaderProgramType { DebugBorderProgram, ScrollLayerProgram, ContentLayerProgram, CanvasLayerProgram, NumShaderProgramTypes }; > > diff --git a/WebKit/chromium/ChangeLog b/WebKit/chromium/ChangeLog > index c5b2a5d..c8c919b 100644 > --- a/WebKit/chromium/ChangeLog > +++ b/WebKit/chromium/ChangeLog > @@ -1,3 +1,18 @@ > +2010-08-17 W. James MacLean <wjmaclean@google.com> > + > + Reviewed by NOBODY (OOPS!). > + > + [chromium] Thumbnails not generated for GPU Rendered Pages > + https://bugs.webkit.org/show_bug.cgi?id=44127 > + > + Added functions to allow readback of GPU buffer for generating Chromium thumbnails. > + > + * public/WebView.h: > + (WebKit::WebView::readPixels): > + * src/WebViewImpl.cpp: > + (WebKit::WebViewImpl::readPixels): > + * src/WebViewImpl.h: > + > 2010-08-17 Sheriff Bot <webkit.review.bot@gmail.com> > > Unreviewed, rolling out r65516. > diff --git a/WebKit/chromium/public/WebView.h b/WebKit/chromium/public/WebView.h > index 1b94da2..3433335 100644 > --- a/WebKit/chromium/public/WebView.h > +++ b/WebKit/chromium/public/WebView.h > @@ -212,6 +212,8 @@ public: > // (accept false) effect. Return true on success. > virtual bool setDropEffect(bool accept) = 0; > > + virtual void readPixels(WebCanvas *canvas) {} > + > > // Support for resource loading initiated by plugins ------------------- > > diff --git a/WebKit/chromium/src/WebViewImpl.cpp b/WebKit/chromium/src/WebViewImpl.cpp > index 62b20d5..ff00c9a 100644 > --- a/WebKit/chromium/src/WebViewImpl.cpp > +++ b/WebKit/chromium/src/WebViewImpl.cpp > @@ -943,6 +943,12 @@ void WebViewImpl::layout() > } > } > > +void WebViewImpl::readPixels(WebCanvas *canvas) > +{ > + ASSERT(isAcceleratedCompositingActive()); > + m_layerRenderer->readPixels(canvas); > +} > + > void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect) > { > > diff --git a/WebKit/chromium/src/WebViewImpl.h b/WebKit/chromium/src/WebViewImpl.h > index c296121..9b0906c 100644 > --- a/WebKit/chromium/src/WebViewImpl.h > +++ b/WebKit/chromium/src/WebViewImpl.h > @@ -158,6 +158,7 @@ public: > const WebPoint& screenPoint); > virtual int dragIdentity(); > virtual bool setDropEffect(bool accept); > + virtual void readPixels(WebCanvas *canvas); > virtual unsigned long createUniqueIdentifierForRequest(); > virtual void inspectElementAt(const WebPoint& point); > virtual WebString inspectorSettings() const; WebCore/ChangeLog:8 + Added functions to allow readback of GPU buffer for generating Chromium thumbnails. Usually you would put the above line at the top of the changelog (following [chromium]) and then just provide a link to the bug. No need to repeat the bug description here. WebKit/chromium/ChangeLog:8 + Added functions to allow readback of GPU buffer for generating Chromium thumbnails. In this changelog entry you can be more specific about the changes you made to the WebKit/chromium side, for example something like "Adding a method to WebViewImpl to read the contents of a composited page" WebKit/chromium/public/WebView.h:215 + virtual void readPixels(WebCanvas *canvas) {} Does this method need to appear in WebView or just WebViewImpl? Generally the WebView API is a pure virtual one. WebKit/chromium/src/WebViewImpl.cpp:948 + ASSERT(isAcceleratedCompositingActive()); Is this method only called if acceleratedCompositing is active? It seems that this ASSERT() should be converted to an if () and have a different path if you're not using accelerated compositing. In either case though, the code needs to be withing a: #if USE(ACCELERATED_COMPOSITING) block WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:509 + void LayerRendererChromium::readPixels(skia::PlatformCanvas* canvasPtr) Skia is only used on windows and linux. We'll need a CG path for the mac. A good example of similar code is in: GraphicsContext3DInternal::paintRenderingResultsToCanvas() WebCore/platform/graphics/chromium/LayerRendererChromium.h:90 + void readPixels(skia::PlatformCanvas* canvasPtr); nit: Use a more descriptive name for this method like: getFramebufferPixels() or something of that sort? 265876 6 64628 levin 2010-08-17 17:47:26 -0700 Comment on attachment 64628 Patch to allow pixel readback from GPU for thumbnail generation. r- see Vangelis' comment (and a minor style issue in the bug too) plus the style issue below. WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:509 + void LayerRendererChromium::readPixels(skia::PlatformCanvas* canvasPtr) Just canvas should suffice. WebKit avoids abbreviates and in general adding type information to variable names (so Ptr is out on both accounts). WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:526 + // Flip pixels vertically ... "// Flip pixels vertically." works too. This comes from a person who uses "..." to often in the past.... WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:529 + unsigned char *ptr1 = static_cast<unsigned char *>(pixels) + row1 * bitmap.rowBytes(); The * (when used as a pointer as opposed to multiplication) should be near the type. There are lots of instances of this problem in this patch. WebKit/chromium/public/WebView.h:215 + virtual void readPixels(WebCanvas *canvas) {} The parameter name |canvas| adds no information in the function definition, so it should be omitted. (There are other instances of this.) Also WebKit tends to put a space inside of braces like this, so s/{}/{ }/ (And the * is in the wrong place.) 266117 7 wjmaclean 2010-08-18 08:30:04 -0700 (In reply to comment #5) > > WebKit/chromium/public/WebView.h:215 > + virtual void readPixels(WebCanvas *canvas) {} > Does this method need to appear in WebView or just WebViewImpl? Generally the WebView API is a pure virtual one. I put a default implementation in since I wasn't sure what else might be inheriting from WebView ... I've made it pure virtual. > WebKit/chromium/src/WebViewImpl.cpp:948 > + ASSERT(isAcceleratedCompositingActive()); > Is this method only called if acceleratedCompositing is active? It seems that this ASSERT() should be converted to an if () and have a different path if you're not using accelerated compositing. In either case though, the code needs to be withing a: > #if USE(ACCELERATED_COMPOSITING) > block The chromium-side code ensures this method is only called if acceleratedCompositing is active. I can wrap it in #if USE(ACCELERATED_COMPOSITING) no problem, but then should I wrap all my plumbing methods as well? > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:509 > + void LayerRendererChromium::readPixels(skia::PlatformCanvas* canvasPtr) > Skia is only used on windows and linux. We'll need a CG path for the mac. A good example of similar code is in: GraphicsContext3DInternal::paintRenderingResultsToCanvas() OK. To make the interface in LayerRendererChromium as generic as possible I'd like to pass the context as a WebCanvas*, but I can't seem to figure out how to get WebCanvas.h included in LayerRendererChromium.h (file not found). Suggestions? > WebCore/platform/graphics/chromium/LayerRendererChromium.h:90 > + void readPixels(skia::PlatformCanvas* canvasPtr); > nit: Use a more descriptive name for this method like: getFramebufferPixels() or something of that sort? Done. 266233 8 vangelis 2010-08-18 10:48:02 -0700 (In reply to comment #7) > (In reply to comment #5) > > > > WebKit/chromium/public/WebView.h:215 > > + virtual void readPixels(WebCanvas *canvas) {} > > Does this method need to appear in WebView or just WebViewImpl? Generally the WebView API is a pure virtual one. > > I put a default implementation in since I wasn't sure what else might be inheriting from WebView ... I've made it pure virtual. From the chromium code, do you use a pointer to a WebViewImpl or to a WebView? If you can please post the chromium patch as well in the chrome bug tracker, I get a better picture of how things are hooked up. > > > WebKit/chromium/src/WebViewImpl.cpp:948 > > + ASSERT(isAcceleratedCompositingActive()); > > Is this method only called if acceleratedCompositing is active? It seems that this ASSERT() should be converted to an if () and have a different path if you're not using accelerated compositing. In either case though, the code needs to be withing a: > > #if USE(ACCELERATED_COMPOSITING) > > block > > The chromium-side code ensures this method is only called if acceleratedCompositing is active. I can wrap it in #if USE(ACCELERATED_COMPOSITING) no problem, but then should I wrap all my plumbing methods as well? A lot of the methods related to accelerated compositing are behind that guard so the code won't compile if ACCELERATED_COMPOSITING is not defined. isAcceleratedCompositingActive() is definitely one of them. > > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:509 > > + void LayerRendererChromium::readPixels(skia::PlatformCanvas* canvasPtr) > > Skia is only used on windows and linux. We'll need a CG path for the mac. A good example of similar code is in: GraphicsContext3DInternal::paintRenderingResultsToCanvas() > > OK. To make the interface in LayerRendererChromium as generic as possible I'd like to pass the context as a WebCanvas*, but I can't seem to figure out how to get WebCanvas.h included in LayerRendererChromium.h (file not found). Suggestions? I take that back. Skia::PlatformCanvas seems to be available on the mac as well as it's apparently used to transfer bits between the renderer and the browser process. It's worth trying to compile the code on the mac to see how things do. > > > WebCore/platform/graphics/chromium/LayerRendererChromium.h:90 > > + void readPixels(skia::PlatformCanvas* canvasPtr); > > nit: Use a more descriptive name for this method like: getFramebufferPixels() or something of that sort? > > Done. 266847 9 64877 wjmaclean 2010-08-19 11:21:14 -0700 Created attachment 64877 Patch 266849 10 webkit.review.bot 2010-08-19 11:22:21 -0700 Attachment 64877 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebKit/chromium/src/WebViewImpl.cpp:961: Use 0 instead of NULL. [readability/null] [4] Total errors found: 1 in 5 files If any of these errors are false positives, please file a bug against check-webkit-style. 266898 11 64877 vangelis 2010-08-19 12:38:37 -0700 Comment on attachment 64877 Patch > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index ad3ea90fa97c706ed4ce0ea385d2c93998d925cc..0ad1ee5530eed1141cb54f4fe61aa03a059a9c50 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,16 @@ > +2010-08-19 W. James MacLean <wjmaclean@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + [chromium] Thumbnails not generated for GPU Rendered Pages > + https://bugs.webkit.org/show_bug.cgi?id=44127 > + > + Replicates existing functionality, use existing tests. > + > + * platform/graphics/chromium/LayerRendererChromium.cpp: > + (WebCore::LayerRendererChromium::getFramebufferPixels): > + * platform/graphics/chromium/LayerRendererChromium.h: > + > 2010-08-17 Darin Fisher <darin@chromium.org> > > Reviewed by Darin Adler. > diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > index 2f70efad02606b6a37a1218f93b6dcb73e1de796..04b69e11dc31dbf6786dc0569b2f3a5e9ade6106 100644 > --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > @@ -506,6 +506,33 @@ void LayerRendererChromium::drawLayers(const IntRect& updateRect, const IntRect& > m_needsDisplay = false; > } > > +void LayerRendererChromium::getFramebufferPixels(void *pixels, const int width, const int height, const int rowBytes) > +{ > + if (!pixels) > + return; > + > + makeContextCurrent(); > + > + checkGLError(); > + > + glReadPixels(0, 0, width, height, > + GL_RGBA, GL_UNSIGNED_BYTE, pixels); > + > + checkGLError(); > + > + // Flip pixels vertically. > + OwnPtr<unsigned char> lineTemp(new unsigned char[rowBytes]); > + for (int row1 = 0, row2 = height - 1; row1 < height / 2; ++row1, --row2) { > + > + unsigned char* ptr1 = static_cast<unsigned char*>(pixels) + row1 * rowBytes; > + unsigned char* ptr2 = static_cast<unsigned char*>(pixels) + row2 * rowBytes; > + > + memcpy(lineTemp.get(), ptr1, rowBytes); > + memcpy(ptr1, ptr2, rowBytes); > + memcpy(ptr2, lineTemp.get(), rowBytes); > + } > +} > + > // Returns the id of the texture currently associated with the layer or > // -1 if the id hasn't been registered yet. > int LayerRendererChromium::getTextureId(LayerChromium* layer) > diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.h b/WebCore/platform/graphics/chromium/LayerRendererChromium.h > index e4474b5a0251d53a073d4b7590a057d9f91b6639..ae9f55cb3e634211d62c30f0103b300278b8782b 100644 > --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.h > +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.h > @@ -87,6 +87,8 @@ public: > > GraphicsContext* rootLayerGraphicsContext() const { return m_rootLayerGraphicsContext.get(); } > > + void getFramebufferPixels(void *pixels, const int width, const int height, const int rowBytes); > + > private: > enum ShaderProgramType { DebugBorderProgram, ScrollLayerProgram, ContentLayerProgram, CanvasLayerProgram, NumShaderProgramTypes }; > > diff --git a/WebKit/chromium/ChangeLog b/WebKit/chromium/ChangeLog > index c5b2a5d467a378d74a06bd2021c0b2f4c9c74173..6c10f07439458543c6d5d4ba7bff181d5997cdc7 100644 > --- a/WebKit/chromium/ChangeLog > +++ b/WebKit/chromium/ChangeLog > @@ -1,3 +1,17 @@ > +2010-08-19 W. James MacLean <wjmaclean@google.com> > + > + Reviewed by NOBODY (OOPS!). > + > + [chromium] Thumbnails not generated for GPU Rendered Pages > + https://bugs.webkit.org/show_bug.cgi?id=44127 > + > + Modified WebViewImpl::paint() to detect non-null canvas pointers when > + accelerated compositing is active, and instead fills the pixel buffer > + from the GPU framebuffer. > + > + * src/WebViewImpl.cpp: > + (WebKit::WebViewImpl::paint): > + > 2010-08-17 Sheriff Bot <webkit.review.bot@gmail.com> > > Unreviewed, rolling out r65516. > diff --git a/WebKit/chromium/src/WebViewImpl.cpp b/WebKit/chromium/src/WebViewImpl.cpp > index 62b20d5fb59477df2448b03ba95e883051a19b1d..5d862472afbb86e92aff3b33aa92284de4ba31c0 100644 > --- a/WebKit/chromium/src/WebViewImpl.cpp > +++ b/WebKit/chromium/src/WebViewImpl.cpp > @@ -114,6 +114,10 @@ > #include "WebViewClient.h" > #include "wtf/OwnPtr.h" > > +#if WEBKIT_USING_CG > +#include <CoreGraphics/CGContext.h> > +#endif > + > #if OS(WINDOWS) > #include "RenderThemeChromiumWin.h" > #else > @@ -954,6 +958,35 @@ void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect) > webframe->paint(canvas, rect); > #if USE(ACCELERATED_COMPOSITING) > } else { > + // If canvas is non-NULL, we just read the pixels from > + // the GPU framebuffer. > + if (canvas) { > +#if WEBKIT_USING_SKIA > + const SkBitmap bitmap = canvas->getDevice()->accessBitmap(false); > + > + int width = bitmap.width(); > + int height = bitmap.height(); > + int rowBytes = bitmap.rowBytes(); > + > + SkAutoLockPixels bitmapLock(bitmap); > + void* pixels = bitmap.getPixels(); > +#elif WEBKIT_USING_CG > + CGContextRef bitmap = reinterpret_cast<CGContextRef>(canvas); > + > + int width = CGBitmapContextGetWidth(bitmap); > + int height = CGBitmapContextGetHeight(bitmap); > + int rowBytes = CGBitmapContextGetBytesPerRow(bitmap); > + > + void* pixels = CGBitmapContextGetData(bitmap); > + ASSERT(pixels); > +#else > +#error Must port to your platform. > +#endif > + > + m_layerRenderer->getFramebufferPixels(pixels, width, height, rowBytes); > + return; > + } > + > // Draw the contents of the root layer. > updateRootLayerContents(rect); > WebKit/chromium/src/WebViewImpl.cpp:981 + ASSERT(pixels); This ASSERT could move outside the #if clause so that it runs for both Skia and CG WebKit/chromium/src/WebViewImpl.cpp:963 + if (canvas) { This code will probably need to move after the call to m_layerRenderer->drawLayers() so that we get fresh results. I guess the problem is that drawLayers calls swap buffers so it will be too late. A possible solution would be to split the call to swap buffers out to a different function (say: LayerRendererChromium::present()) and call that from WebViewImpl, after drawLayers and readFramebufferPixels. WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:518 + glReadPixels(0, 0, width, height, Are there any guarantees that the width and height passed in match those of the framebuffer? You should probably at a minimum put an assert there and/or clamp to the size of the framebuffer. 266937 12 wjmaclean 2010-08-19 13:49:24 -0700 (In reply to comment #11) > > WebKit/chromium/src/WebViewImpl.cpp:981 > + ASSERT(pixels); > This ASSERT could move outside the #if clause so that it runs for both Skia and CG Sure, done. > WebKit/chromium/src/WebViewImpl.cpp:963 > + if (canvas) { > This code will probably need to move after the call to m_layerRenderer->drawLayers() so that we get fresh results. I guess the problem is that drawLayers calls swap buffers so it will be too late. A possible solution would be to split the call to swap buffers out to a different function (say: LayerRendererChromium::present()) and call that from WebViewImpl, after drawLayers and readFramebufferPixels. For thumbnail generation, the logic that invokes WebViewImpl::paint() and provides a non-Null canvas is guaranteed to make that call *after* the page has been rendered (at least) once. Thus far I haven't seen any issues with thumbnails coming back blank, and it would be nice to avoid re-rendering the page just to grab the thumbnail pixels. It's possible to to do something like LayerRendererChromium::present(), but if we're trying to avoid re-rendering in the first place then is it needed? > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:518 > + glReadPixels(0, 0, width, height, > Are there any guarantees that the width and height passed in match those of the framebuffer? You should probably at a minimum put an assert there and/or clamp to the size of the framebuffer. Good idea - should I compare/clamp against m_rootLayerTextureWidth/Height ? 266993 13 vangelis 2010-08-19 15:09:05 -0700 (In reply to comment #12) > (In reply to comment #11) > > > > WebKit/chromium/src/WebViewImpl.cpp:981 > > + ASSERT(pixels); > > This ASSERT could move outside the #if clause so that it runs for both Skia and CG > > Sure, done. > > > WebKit/chromium/src/WebViewImpl.cpp:963 > > + if (canvas) { > > This code will probably need to move after the call to m_layerRenderer->drawLayers() so that we get fresh results. I guess the problem is that drawLayers calls swap buffers so it will be too late. A possible solution would be to split the call to swap buffers out to a different function (say: LayerRendererChromium::present()) and call that from WebViewImpl, after drawLayers and readFramebufferPixels. > > For thumbnail generation, the logic that invokes WebViewImpl::paint() and provides a non-Null canvas is guaranteed to make that call *after* the page has been rendered (at least) once. Thus far I haven't seen any issues with thumbnails coming back blank, and it would be nice to avoid re-rendering the page just to grab the thumbnail pixels. > > It's possible to to do something like LayerRendererChromium::present(), but if we're trying to avoid re-rendering in the first place then is it needed? I think that since you opted for a more general solution of integrating the readback in the paint method (which is a good thing), you cannot make assumptions on how this method will be called and whether the compositor will have rendered something before. I think splitting out the swapbuffers call is worth it here, and is a fairly small change. > > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:518 > > + glReadPixels(0, 0, width, height, > > Are there any guarantees that the width and height passed in match those of the framebuffer? You should probably at a minimum put an assert there and/or clamp to the size of the framebuffer. > > Good idea - should I compare/clamp against m_rootLayerTextureWidth/Height ? yes, those are good values to clamp against. 267223 14 wjmaclean 2010-08-20 06:01:01 -0700 (In reply to comment #13) > > I think that since you opted for a more general solution of integrating the readback in the paint method (which is a good thing), you cannot make assumptions on how this method will be called and whether the compositor will have rendered something before. I think splitting out the swapbuffers call is worth it here, and is a fairly small change. No problem, I just wanted to be clear about this since we had discussed pure read-back earlier. I'll implement this today, but as I'm working OOO today I may not be able to test the changes until Monday morning, so will re-submit the patch then. > > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:518 > > > + glReadPixels(0, 0, width, height, > > > Are there any guarantees that the width and height passed in match those of the framebuffer? You should probably at a minimum put an assert there and/or clamp to the size of the framebuffer. > > > > Good idea - should I compare/clamp against m_rootLayerTextureWidth/Height ? > > yes, those are good values to clamp against. Done! 269458 15 65465 wjmaclean 2010-08-25 13:16:33 -0700 Created attachment 65465 Patch 269460 16 wjmaclean 2010-08-25 13:19:48 -0700 (In reply to comment #15) > Created an attachment (id=65465) [details] > Patch This new patch includes support for mis-match between the size of the current render-layer and the canvas provided to contain the read-back pixels. Includes revisions to merge with recent changes to LayerRendererChromium.[h|cpp]. 269505 17 65465 vangelis 2010-08-25 14:23:33 -0700 Comment on attachment 65465 Patch > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index eb5910eda9a40bf990446c741d3d1a25b1621ae7..58447952d5a92685ee5ff989361a79e6b3cedbd2 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,23 @@ > +2010-08-25 W. James MacLean <wjmaclean@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + [chromium] Thumbnails not generated for GPU Rendered Pages > + https://bugs.webkit.org/show_bug.cgi?id=44127 > + > + Replicates existing functionality, use existing tests. > + > + Adds pixel-readback for GPU composited pages to allow for thumbnailing, > + printing and other services to work with GPU rendered pages. > + > + * platform/graphics/chromium/LayerRendererChromium.cpp: > + (WebCore::LayerRendererChromium::drawLayers): > + (WebCore::LayerRendererChromium::present): > + (WebCore::LayerRendererChromium::getFramebufferPixels): > + * platform/graphics/chromium/LayerRendererChromium.h: > + (WebCore::LayerRendererChromium::getRootLayerTextureWidth): > + (WebCore::LayerRendererChromium::getRootLayerTextureHeight): > + > 2010-08-25 Ilya Tikhonovsky <loislo@chromium.org> > > Reviewed by Yury Semikhatsky. > diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > index cf238718b21bb40bb6976627d9f233854e4469fb..bacc852b0db1cdc3e8fa2e27e722a8cd5f4daf32 100644 > --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > @@ -310,11 +310,41 @@ void LayerRendererChromium::drawLayers(const IntRect& updateRect, const IntRect& > > GLC(glDisable(GL_SCISSOR_TEST)); > > + glFlush(); > +} > + > +void LayerRendererChromium::present() > +{ > m_gles2Context->swapBuffers(); > > m_needsDisplay = false; > } > > +void LayerRendererChromium::getFramebufferPixels(void *pixels, const int width, const int height, const int rowBytes) > +{ > + ASSERT(width == m_rootLayerTextureWidth && height == m_rootLayerTextureHeight); > + > + if (!pixels) > + return; > + > + makeContextCurrent(); > + > + GLC(glReadPixels(0, 0, width, height, > + GL_RGBA, GL_UNSIGNED_BYTE, pixels)); > + > + // Flip pixels vertically. > + OwnPtr<unsigned char> lineTemp(new unsigned char[rowBytes]); > + for (int row1 = 0, row2 = height - 1; row1 < height / 2; ++row1, --row2) { > + > + unsigned char* ptr1 = static_cast<unsigned char*>(pixels) + row1 * rowBytes; > + unsigned char* ptr2 = static_cast<unsigned char*>(pixels) + row2 * rowBytes; > + > + memcpy(lineTemp.get(), ptr1, rowBytes); > + memcpy(ptr1, ptr2, rowBytes); > + memcpy(ptr2, lineTemp.get(), rowBytes); > + } > +} > + > // FIXME: This method should eventually be replaced by a proper texture manager. > unsigned LayerRendererChromium::createLayerTexture() > { > diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.h b/WebCore/platform/graphics/chromium/LayerRendererChromium.h > index 24bbe652828c1f98a531e2128f6918d1e9e8c363..b5c93871b09f7557f015f2f755e86e11d585505b 100644 > --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.h > +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.h > @@ -64,6 +64,7 @@ public: > // Updates the contents of the root layer that fall inside the updateRect and recomposites > // all the layers. > void drawLayers(const IntRect& updateRect, const IntRect& visibleRect, const IntRect& contentRect, const IntPoint& scrollPosition); > + void present(); // Perform buffer swap to present rendered buffer. > > void setRootLayer(PassRefPtr<LayerChromium> layer) { m_rootLayer = layer; } > LayerChromium* rootLayer() { return m_rootLayer.get(); } > @@ -90,6 +91,10 @@ public: > const ContentLayerChromium::SharedValues* contentLayerSharedValues() const { return m_contentLayerSharedValues.get(); } > const CanvasLayerChromium::SharedValues* canvasLayerSharedValues() const { return m_canvasLayerSharedValues.get(); } > > + int getRootLayerTextureWidth() const { return m_rootLayerTextureWidth; } > + int getRootLayerTextureHeight() const { return m_rootLayerTextureHeight; } > + void getFramebufferPixels(void *pixels, const int width, const int height, const int rowBytes); > + > private: > void updateLayersRecursive(LayerChromium* layer, const TransformationMatrix& parentMatrix, float opacity); > > diff --git a/WebKit/chromium/ChangeLog b/WebKit/chromium/ChangeLog > index 5d860ed71441c401246d8dfc17723e5ebe9bfa41..6c6942c16cdb56a607b1fb424e900864e8aa92bc 100644 > --- a/WebKit/chromium/ChangeLog > +++ b/WebKit/chromium/ChangeLog > @@ -1,3 +1,18 @@ > +2010-08-25 W. James MacLean <wjmaclean@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + [chromium] Thumbnails not generated for GPU Rendered Pages > + https://bugs.webkit.org/show_bug.cgi?id=44127 > + > + Modified WebViewImpl::paint() to detect non-null canvas pointers when > + accelerated compositing is active, and instead fills the pixel buffer > + from the GPU framebuffer. Includes re-scaling support when provided > + canvas does not match size of current render layer. > + > + * src/WebViewImpl.cpp: > + (WebKit::WebViewImpl::paint): > + > 2010-08-25 Satish Sampath <satish@chromium.org> > > Reviewed by Jeremy Orlow. > diff --git a/WebKit/chromium/src/WebViewImpl.cpp b/WebKit/chromium/src/WebViewImpl.cpp > index 383b7167314edaf342daeb48f3b56610ed753148..4bd56c09910108fb626c068845c8add40249cf87 100644 > --- a/WebKit/chromium/src/WebViewImpl.cpp > +++ b/WebKit/chromium/src/WebViewImpl.cpp > @@ -115,6 +115,10 @@ > #include "WebViewClient.h" > #include "wtf/OwnPtr.h" > > +#if WEBKIT_USING_CG > +#include <CoreGraphics/CGContext.h> > +#endif > + > #if OS(WINDOWS) > #include "RenderThemeChromiumWin.h" > #else > @@ -955,6 +959,7 @@ void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect) > webframe->paint(canvas, rect); > #if USE(ACCELERATED_COMPOSITING) > } else { > + > // Draw the contents of the root layer. > updateRootLayerContents(rect); > > @@ -971,6 +976,78 @@ void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect) > > // Ask the layer compositor to redraw all the layers. > m_layerRenderer->drawLayers(rect, visibleRect, contentRect, IntPoint(view->scrollX(), view->scrollY())); > + > + // If a canvas was passed in, we use it to grab a copy of the > + // freshly-rendered pixels. > + if (canvas) { > + void* pixels = 0; > +#if WEBKIT_USING_SKIA > + const SkBitmap bitmap = canvas->getDevice()->accessBitmap(false); > + > + int width = bitmap.width(); > + int height = bitmap.height(); > + int rowBytes = bitmap.rowBytes(); > + > + SkAutoLockPixels bitmapLock(bitmap); > + > + if (m_layerRenderer->getRootLayerTextureWidth() == width > + && m_layerRenderer->getRootLayerTextureHeight() == height) { > + pixels = bitmap.getPixels(); > + m_layerRenderer->getFramebufferPixels(pixels, width, height, rowBytes); > + } else { > + width = m_layerRenderer->getRootLayerTextureWidth(); > + height = m_layerRenderer->getRootLayerTextureHeight(); > + > + // Create temp bitmap of correct size to copy pixels into. > + OwnPtr<skia::PlatformCanvas> canvas2 = OwnPtr<skia::PlatformCanvas>(new skia::PlatformCanvas()); > + if (canvas2.get() && canvas2->initialize(width, height, true)) { > + SkBitmap bitmap2 = canvas2->getDevice()->accessBitmap(false); > + pixels = bitmap2.getPixels(); > + m_layerRenderer->getFramebufferPixels(pixels, width, height, rowBytes); > + canvas->drawBitmap(bitmap2, 0, 0, 0); > + } > + } > +#elif WEBKIT_USING_CG > + CGContextRef bitmap = reinterpret_cast<CGContextRef>(canvas); > + > + int width = CGBitmapContextGetWidth(bitmap); > + int height = CGBitmapContextGetHeight(bitmap); > + int rowBytes = CGBitmapContextGetBytesPerRow(bitmap); > + > + if (m_layerRenderer->getRootLayerTextureWidth() == width > + && m_layerRenderer->getRootLayerTextureHeight() == height) { > + pixels = CGBitmapContextGetData(bitmap); > + m_layerRenderer->getFramebufferPixels(pixels, width, height, rowBytes); > + } else { > + width = m_layerRenderer->getRootLayerTextureWidth(); > + height = m_layerRenderer->getRootLayerTextureHeight(); > + > + // Create temp bitmap of same size as rendered layer to copy pixels into. > + CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB(); > + CGContextRef bitmap2 = CGBitmapContextCreate(0, width, height, 8, 4 * width, colorSpace, > + kCGImageAlphaPremultipliedLast); > + if (bitmap2) { > + pixels = CGBitmapContextGetData(bitmap2); > + m_layerRenderer->getFramebufferPixels(pixels, width, height, rowBytes); > + > + // Copy bitmap back to input bitmap. The image is inverted according to CG, > + // so set up the appropriate transform to invert vertical axis and move origin > + // to bottom left. > + CGContextSaveGState(bitmap); > + CGContextTranslateCTM(bitmap, 0, CGBitmapContextGetHeight(bitmap)); > + CGContextScaleCTM(bitmap, 1.0, -1.0); > + CGContextDrawImage(bitmap, > + CGRectMake(0, 0, CGBitmapContextGetWidth(bitmap), CGBitmapContextGetHeight(bitmap)), > + CGBitmapContextCreateImage(bitmap2)); > + CGContextRestoreGState(bitmap); > + } > + } > +#else > +#error Must port to your platform. > +#endif > + } > + > + m_layerRenderer->present(); // Do final display by swapping buffers. > } > #endif > } WebCore/platform/graphics/chromium/LayerRendererChromium.h:94 + int getRootLayerTextureWidth() const { return m_rootLayerTextureWidth; } Accessors don't typically start with get. These two should be: rootLayerTextureWidth() and rootLayerTextureHeight() WebKit/chromium/src/WebViewImpl.cpp:118 + #if WEBKIT_USING_CG The WebCore code has been using #if PLATFORM(CG) instead of WEBKIT_USING_CG WebKit/chromium/src/WebViewImpl.cpp:984 + #if WEBKIT_USING_SKIA #if PLATFORM(SKIA) WebKit/chromium/src/WebViewImpl.cpp:989 + int rowBytes = bitmap.rowBytes(); In getFramebufferPixels() we assume that we have 4 bytes per pixel (RGBA). If rowBytes doesn't match 4*width then we're in trouble. Maybe better here to do an: ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config) and not pass the rowBytes down to getFrameBufferPixels. WebKit/chromium/src/WebViewImpl.cpp:1002 + OwnPtr<skia::PlatformCanvas> canvas2 = OwnPtr<skia::PlatformCanvas>(new skia::PlatformCanvas()); Please use a more descriptive name for canvas2 and bitmap2 WebKit/chromium/src/WebViewImpl.cpp:1016 + ASSERT(rowBytes == width * 4) WebKit/chromium/src/WebViewImpl.cpp:1007 + canvas->drawBitmap(bitmap2, 0, 0, 0); I think you want to call drawBitmapRect here to specify that the target size if the size of your WebCanvas so that you get the scaling. WebKit/chromium/src/WebViewImpl.cpp:999 + height = m_layerRenderer->getRootLayerTextureHeight(); these variables shadow the width and height defined in the outside scope and make things confusing (plus I think you need the canvas width further down anyway). Please rename. WebKit/chromium/src/WebViewImpl.cpp:1010 + #elif WEBKIT_USING_CG #if PLATFORM(CG) 270508 18 wjmaclean 2010-08-27 08:25:56 -0700 (In reply to comment #17) > (From update of attachment 65465 [details]) > > WebCore/platform/graphics/chromium/LayerRendererChromium.h:94 > + int getRootLayerTextureWidth() const { return m_rootLayerTextureWidth; } > Accessors don't typically start with get. These two should be: rootLayerTextureWidth() and rootLayerTextureHeight() Done. > WebKit/chromium/src/WebViewImpl.cpp:118 > + #if WEBKIT_USING_CG > The WebCore code has been using > #if PLATFORM(CG) instead of WEBKIT_USING_CG > > WebKit/chromium/src/WebViewImpl.cpp:984 > + #if WEBKIT_USING_SKIA > #if PLATFORM(SKIA) I tried this initially, but it didn't work for me ... PLATFORM(SKIA) was true during compilation on the Mac, meaning the CG code didn't get compiled when it should have. This is why I was using WEBKIT_USING_SKIA and WEBKIT_USING_CG. Any suggestions about what I may have been doing wrong in my use of "#if PLATFORM(SKIA)"? > WebKit/chromium/src/WebViewImpl.cpp:989 > + int rowBytes = bitmap.rowBytes(); > In getFramebufferPixels() we assume that we have 4 bytes per pixel (RGBA). If rowBytes doesn't match 4*width then we're in trouble. Maybe better here to do an: > > ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config) Done. > and not pass the rowBytes down to getFrameBufferPixels. Done. > WebKit/chromium/src/WebViewImpl.cpp:1002 > + OwnPtr<skia::PlatformCanvas> canvas2 = OwnPtr<skia::PlatformCanvas>(new skia::PlatformCanvas()); > Please use a more descriptive name for canvas2 and bitmap2 Done - now canvasResize and bitmapResize > WebKit/chromium/src/WebViewImpl.cpp:1016 > + > ASSERT(rowBytes == width * 4) Done. > WebKit/chromium/src/WebViewImpl.cpp:1007 > + canvas->drawBitmap(bitmap2, 0, 0, 0); > I think you want to call drawBitmapRect here to specify that the target size if the size of your WebCanvas so that you get the scaling. Done. > WebKit/chromium/src/WebViewImpl.cpp:999 > + height = m_layerRenderer->getRootLayerTextureHeight(); > these variables shadow the width and height defined in the outside scope and make things confusing (plus I think you need the canvas width further down anyway). Please rename. Done - widthResize, heightResize > WebKit/chromium/src/WebViewImpl.cpp:1010 > + #elif WEBKIT_USING_CG > #if PLATFORM(CG) See comments above. 271447 19 65918 wjmaclean 2010-08-30 08:54:37 -0700 Created attachment 65918 Patch 271469 20 vangelis 2010-08-30 09:41:08 -0700 Looks good! Just one small comment on the bitmap format test and otherwise should be ready to go. (In reply to comment #18) > (In reply to comment #17) > > (From update of attachment 65465 [details] [details]) > > > > WebCore/platform/graphics/chromium/LayerRendererChromium.h:94 > > + int getRootLayerTextureWidth() const { return m_rootLayerTextureWidth; } > > Accessors don't typically start with get. These two should be: rootLayerTextureWidth() and rootLayerTextureHeight() > > Done. > > > WebKit/chromium/src/WebViewImpl.cpp:118 > > + #if WEBKIT_USING_CG > > The WebCore code has been using > > #if PLATFORM(CG) instead of WEBKIT_USING_CG > > > > WebKit/chromium/src/WebViewImpl.cpp:984 > > + #if WEBKIT_USING_SKIA > > #if PLATFORM(SKIA) > > I tried this initially, but it didn't work for me ... PLATFORM(SKIA) was true during compilation on the Mac, meaning the CG code didn't get compiled when it should have. This is why I was using WEBKIT_USING_SKIA and WEBKIT_USING_CG. > > Any suggestions about what I may have been doing wrong in my use of "#if PLATFORM(SKIA)"? Hmm, is this still an issue? I see that in your patch you're using the PLATFORM() test. As far as I can tell, PLATFORM(SKIA/CG) expands out to WTF_PLATFORM_SKIA/CG . These two are defined in Platform.h, with WTF_PLATFORM_SKIA only defined if OS(DARWIN). > > > WebKit/chromium/src/WebViewImpl.cpp:989 > > + int rowBytes = bitmap.rowBytes(); > > In getFramebufferPixels() we assume that we have 4 bytes per pixel (RGBA). If rowBytes doesn't match 4*width then we're in trouble. Maybe better here to do an: > > > > ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config) > > Done. > We probably need to be a bit more defensive here and bail out if the config is not what we expect, otherwise we'll end up with memory corruption. What about: if (bitmap.config() == SkBitmap::kARGB_8888_Config) { // do the stuff pixels = blah; } else { ASSERT_NOT_REACHED(); } And similarly for the mac code. > > and not pass the rowBytes down to getFrameBufferPixels. > > Done. > > > WebKit/chromium/src/WebViewImpl.cpp:1002 > > + OwnPtr<skia::PlatformCanvas> canvas2 = OwnPtr<skia::PlatformCanvas>(new skia::PlatformCanvas()); > > Please use a more descriptive name for canvas2 and bitmap2 > > Done - now canvasResize and bitmapResize > > > WebKit/chromium/src/WebViewImpl.cpp:1016 > > + > > ASSERT(rowBytes == width * 4) > > Done. > > > WebKit/chromium/src/WebViewImpl.cpp:1007 > > + canvas->drawBitmap(bitmap2, 0, 0, 0); > > I think you want to call drawBitmapRect here to specify that the target size if the size of your WebCanvas so that you get the scaling. > > Done. > > > WebKit/chromium/src/WebViewImpl.cpp:999 > > + height = m_layerRenderer->getRootLayerTextureHeight(); > > these variables shadow the width and height defined in the outside scope and make things confusing (plus I think you need the canvas width further down anyway). Please rename. > > Done - widthResize, heightResize > > > WebKit/chromium/src/WebViewImpl.cpp:1010 > > + #elif WEBKIT_USING_CG > > #if PLATFORM(CG) > > See comments above. 271511 21 wjmaclean 2010-08-30 11:02:37 -0700 (In reply to comment #20) > Looks good! Just one small comment on the bitmap format test and otherwise should be ready to go. > > Hmm, is this still an issue? I see that in your patch you're using the PLATFORM() test. As far as I can tell, PLATFORM(SKIA/CG) expands out to WTF_PLATFORM_SKIA/CG . These two are defined in Platform.h, with WTF_PLATFORM_SKIA only defined if OS(DARWIN). > No, it seems fine. I'm not sure why I was having difficulty with it before, but it seems to be OK now. > We probably need to be a bit more defensive here and bail out if the config is not what we expect, otherwise we'll end up with memory corruption. What about: > > if (bitmap.config() == SkBitmap::kARGB_8888_Config) { > > // do the stuff > pixels = blah; > > } else { > ASSERT_NOT_REACHED(); > } > > And similarly for the mac code. Done. 271516 22 65932 wjmaclean 2010-08-30 11:12:52 -0700 Created attachment 65932 Patch 271521 23 vangelis 2010-08-30 11:36:15 -0700 (In reply to comment #21) > (In reply to comment #20) > > Looks good! Just one small comment on the bitmap format test and otherwise should be ready to go. > > > > Hmm, is this still an issue? I see that in your patch you're using the PLATFORM() test. As far as I can tell, PLATFORM(SKIA/CG) expands out to WTF_PLATFORM_SKIA/CG . These two are defined in Platform.h, with WTF_PLATFORM_SKIA only defined if OS(DARWIN). > > > > No, it seems fine. I'm not sure why I was having difficulty with it before, but it seems to be OK now. > > > We probably need to be a bit more defensive here and bail out if the config is not what we expect, otherwise we'll end up with memory corruption. What about: > > > > if (bitmap.config() == SkBitmap::kARGB_8888_Config) { > > > > // do the stuff > > pixels = blah; > > > > } else { > > ASSERT_NOT_REACHED(); > > } > > > > And similarly for the mac code. > > Done. Sorry, one last thing that just occurred to me: alongside with the ASSERT_NOT_REACHED() we should also clear out the canvas we get passed in so that we don't end up displaying garbage. Painting it white should be sufficient. 271528 24 wjmaclean 2010-08-30 11:45:03 -0700 (In reply to comment #23) > > Sorry, one last thing that just occurred to me: alongside with the ASSERT_NOT_REACHED() we should also clear out the canvas we get passed in so that we don't end up displaying garbage. Painting it white should be sufficient. No problem ... is there a standard way (function call) for doing this? 271535 25 wjmaclean 2010-08-30 11:54:09 -0700 (In reply to comment #24) > > No problem ... is there a standard way (function call) for doing this? I'll try SkBitmap::eraseColor(SkColor c), and see if I can find something similar for CG. 271584 26 65943 wjmaclean 2010-08-30 12:54:31 -0700 Created attachment 65943 Patch 271591 27 65945 wjmaclean 2010-08-30 13:00:04 -0700 Created attachment 65945 Patch 271594 28 wjmaclean 2010-08-30 13:02:35 -0700 (In reply to comment #27) > Created an attachment (id=65945) [details] > Patch Just to confirm: is it OK for me to use CGContextSetRGBFillColor() on a CG bitmap if it is not 32-bit RGBA? 271648 29 vangelis 2010-08-30 14:45:49 -0700 (In reply to comment #28) > (In reply to comment #27) > > Created an attachment (id=65945) [details] [details] > > Patch > > Just to confirm: is it OK for me to use CGContextSetRGBFillColor() on a CG bitmap if it is not 32-bit RGBA? That's a good question. I couldn't tell from the CG docs whether this will work. Another option would be to use: CGContextClearRect and in the Skia case paint to transparent black to match. 272058 30 66041 wjmaclean 2010-08-31 05:52:49 -0700 Created attachment 66041 Patch 272059 31 wjmaclean 2010-08-31 05:55:05 -0700 (In reply to comment #29) > (In reply to comment #28) > > (In reply to comment #27) > > > Created an attachment (id=65945) [details] [details] [details] > > > Patch > > > > Just to confirm: is it OK for me to use CGContextSetRGBFillColor() on a CG bitmap if it is not 32-bit RGBA? > > That's a good question. I couldn't tell from the CG docs whether this will work. Another option would be to use: CGContextClearRect and in the Skia case paint to transparent black to match. I thought the CG docs was a bit unclear on this too. I've changed the code as you suggested, and uploaded a fresh patch. 272253 32 66041 vangelis 2010-08-31 11:56:26 -0700 Comment on attachment 66041 Patch Looks good! 272305 33 66041 fishd 2010-08-31 13:14:33 -0700 Comment on attachment 66041 Patch > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:337 > + OwnPtr<unsigned char> lineTemp(new unsigned char[rowBytes]); nit: use OwnArrayPtr here > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:339 > + nit: remove this extra blank line > WebCore/platform/graphics/chromium/LayerRendererChromium.h:94 > + int rootLayerTextureWidth() const { return m_rootLayerTextureWidth; } nit: this should probably return IntSize: IntSize rootLayerTextureSize() const { ... } There was a thread recently on webkit-dev about how we should be using IntSize, IntPoint, etc. more to help clean up the codebase. > WebCore/platform/graphics/chromium/LayerRendererChromium.h:96 > + void getFramebufferPixels(void *pixels, const int width, const int height); nit: can this function take an IntSize parameter? void getFramebufferPixels(void* pixels, const IntSize&); > WebKit/chromium/src/WebViewImpl.cpp:982 > + if (canvas) { nit: this function is now clearly way too long. please break it up into helper functions: one for SKIA and one for CG. > WebKit/chromium/src/WebViewImpl.cpp:987 > + nit: remove this blank line > WebKit/chromium/src/WebViewImpl.cpp:1002 > + OwnPtr<skia::PlatformCanvas> canvasResize = OwnPtr<skia::PlatformCanvas>(new skia::PlatformCanvas()); why does this PlatformCanvas need to be heap allocated? > WebKit/chromium/src/WebViewImpl.cpp:1010 > + canvas->drawBitmapRect(bitmapResize, &srcRect, dstRect, 0); in ImageSkia.cpp, i see similar code, but it tends to enable filtering when doing linear re-sampling. have you considered replacing all of this code with some code that uses GraphicsContext and BitmapImage? save for the GraphicsContext construction, i bet you could write some portable code for this if you used those classes. WebFrameImpl::paint shows how to setup the GraphicsContext. One more comment: is it really best to implement this using HW readback instead of just engaging the software painting path? 272320 34 wjmaclean 2010-08-31 13:31:13 -0700 (In reply to comment #33) I'll > have you considered replacing all of this code with some code that > uses GraphicsContext and BitmapImage? save for the GraphicsContext > construction, i bet you could write some portable code for this if > you used those classes. WebFrameImpl::paint shows how to setup the > GraphicsContext. I can look into this, assuming the we agree the answer to the next question is 'yes'. > One more comment: is it really best to implement this using HW readback > instead of just engaging the software painting path? I would assume that using both the software and hardware paths is more resource intensive than using a single path, which in this case is (by definition) hardware. Secondly, presumably since we are using HW to speed things up, then this would also be desirable for thumbnail generation to also be accelerated (especially if the page is dynamic, and may need to be rendered repeatedly, meaning thumbnail generation could slow down subsequent page renders). Finally, I don't know if it makes the controlling logic more complicated to have two different paths for rendering the same page, but I suspect it does. Vangelis may have some additional thoughts here. If you agree that HW readback is worthwhile for thumbnail generation, then I can proceed to look into the remaining issues. 272330 35 fishd 2010-08-31 13:41:00 -0700 (In reply to comment #34) > I would assume that using both the software and hardware paths is more resource intensive than using a single path, which in this case is (by definition) hardware. Secondly, presumably since we are using HW to speed things up, then this would also be desirable for thumbnail generation to also be accelerated (especially if the page is dynamic, and may need to be rendered repeatedly, meaning thumbnail generation could slow down subsequent page renders). > > Finally, I don't know if it makes the controlling logic more complicated to have two different paths for rendering the same page, but I suspect it does. > > Vangelis may have some additional thoughts here. > > If you agree that HW readback is worthwhile for thumbnail generation, then I can proceed to look into the remaining issues. Hmm, yeah upon reflection I agree that it seems like HW readback is the right answer. 272346 36 vangelis 2010-08-31 13:59:11 -0700 (In reply to comment #35) > (In reply to comment #34) > > I would assume that using both the software and hardware paths is more resource intensive than using a single path, which in this case is (by definition) hardware. Secondly, presumably since we are using HW to speed things up, then this would also be desirable for thumbnail generation to also be accelerated (especially if the page is dynamic, and may need to be rendered repeatedly, meaning thumbnail generation could slow down subsequent page renders). > > > > Finally, I don't know if it makes the controlling logic more complicated to have two different paths for rendering the same page, but I suspect it does. > > > > Vangelis may have some additional thoughts here. > > > > If you agree that HW readback is worthwhile for thumbnail generation, then I can proceed to look into the remaining issues. > > Hmm, yeah upon reflection I agree that it seems like HW readback is the right answer. Without h/w readback we'll be unable to capture the contents of WebGL, accelerated Canvas2D, and 3D CSS-transformed layers. So I don't think software is an option here. 272819 37 wjmaclean 2010-09-01 08:45:37 -0700 (In reply to comment #33) > > have you considered replacing all of this code with some code that > uses GraphicsContext and BitmapImage? save for the GraphicsContext > construction, i bet you could write some portable code for this if > you used those classes. WebFrameImpl::paint shows how to setup the > GraphicsContext. I've looked through the WebCore/platform/graphics code, and I think I've identified a way to make the code more portable. The initial creation of a GraphicsContext requires some #if's, and it is slightly less efficient as it seems it's hard to get access to the input canvas pixels in a platform-agnostic way, necessitating an intermediary buffer (but perhaps I'm missing something ...). Any implementation will include appropriate use of IntSize. Here's a tentative sketch of how this might work (but I'm looking for advice here, as there may be better ways to achieve this): 1) Create a GraphicsContext as follows: #if PLATFORM(CG) GraphicsContext gc(canvas); #elif PLATFORM(SKIA) PlatformContextSkia context(canvas); // PlatformGraphicsContext is actually a pointer to PlatformContextSkia GraphicsContext gc(reinterpret_cast<PlatformGraphicsContext*>(&context)); #else notImplemented(); #endif Not platform independent, but it's small. 2) Create an ImageBuffer object (ARGB) of the same size as the rootTextureLayer (this requires us to always allocate another buffer ... potentially wasteful, but avoids checking for mis-match in canvas size) ImageBuffer imageBuffer(); 3) From the ImageBuffer object, extract pointer to underlying pixels: imageBuffer.getUnmultipliedImageData(rootLayerRect)->data().get(0).data() - returns pointer to unsigned char* - presumably getUnmultipliedImageData() doesn't mind us modifying the underlying pixels ... 4) Pass pointer to getFrameBufferPixels. 5) Draw ImageBuffer object into gc using drawImageBuffer() - Not sure about what sort of re-scaling (if any) is available here ... - I assume this would handle canvas-size-mismatch transparently, but needs verification ... 6) If any of this fails, call gc.clearRect(rootLayerRect); Questions: There seems no obvious way to get the 'size' of a GraphicsContext ... is it assumed to be an infinite (but possibly clipped to some underlying bitmap) drawing plane? 272858 38 fishd 2010-09-01 09:53:34 -0700 > Without h/w readback we'll be unable to capture the contents of WebGL, > accelerated Canvas2D, and 3D CSS-transformed layers. So I don't think software > is an option here. d'oh, of course! > Not platform independent, but it's small. Yeah, that's basically what I was hoping for. > 2) Create an ImageBuffer object (ARGB) of the same size as the rootTextureLayer > (this requires us to always allocate another buffer ... potentially wasteful, > but avoids checking for mis-match in canvas size) If the result is less efficient, then it probably isn't worth it. I was hoping it would be possible to minimize platform dependent code without any change in functionality. If that doesn't look possible, then going with platform specific code sounds better... just try to break up the function so that it is not so long. > There seems no obvious way to get the 'size' of a GraphicsContext ... is it > assumed to be an infinite (but possibly clipped to some underlying bitmap) > drawing plane? Yes. 272944 39 vangelis 2010-09-01 12:48:26 -0700 (In reply to comment #37) > (In reply to comment #33) > > > > have you considered replacing all of this code with some code that > > uses GraphicsContext and BitmapImage? save for the GraphicsContext > > construction, i bet you could write some portable code for this if > > you used those classes. WebFrameImpl::paint shows how to setup the > > GraphicsContext. > > I've looked through the WebCore/platform/graphics code, and I think I've identified a way to make the code more portable. The initial creation of a GraphicsContext requires some #if's, and it is slightly less efficient as it seems it's hard to get access to the input canvas pixels in a platform-agnostic way, necessitating an intermediary buffer (but perhaps I'm missing something ...). Any implementation will include appropriate use of IntSize. > > Here's a tentative sketch of how this might work (but I'm looking for advice here, as there may be better ways to achieve this): > > 1) Create a GraphicsContext as follows: > > #if PLATFORM(CG) > GraphicsContext gc(canvas); > #elif PLATFORM(SKIA) > PlatformContextSkia context(canvas); > > // PlatformGraphicsContext is actually a pointer to PlatformContextSkia > GraphicsContext gc(reinterpret_cast<PlatformGraphicsContext*>(&context)); > #else > notImplemented(); > #endif > > Not platform independent, but it's small. > > 2) Create an ImageBuffer object (ARGB) of the same size as the rootTextureLayer (this requires us to always allocate another buffer ... potentially wasteful, but avoids checking for mis-match in canvas size) > > ImageBuffer imageBuffer(); > > 3) From the ImageBuffer object, extract pointer to underlying pixels: > > imageBuffer.getUnmultipliedImageData(rootLayerRect)->data().get(0).data() > > - returns pointer to unsigned char* > - presumably getUnmultipliedImageData() doesn't mind us modifying the underlying pixels ... Unfortunately this seems to be an output-only method. You don't get a pointer to the actual pixels in the ImageBuffer. I've been looking around at the code to see if there's any other way to poke new pixels into an ImageBuffer and the only way seems to be to create a GraphicsContext around it which is essentially the code you've had up to now. > > 4) Pass pointer to getFrameBufferPixels. > > 5) Draw ImageBuffer object into gc using drawImageBuffer() > > - Not sure about what sort of re-scaling (if any) is available here ... > - I assume this would handle canvas-size-mismatch transparently, but needs verification ... > > 6) If any of this fails, call gc.clearRect(rootLayerRect); > > Questions: > > There seems no obvious way to get the 'size' of a GraphicsContext ... is it assumed to be an infinite (but possibly clipped to some underlying bitmap) drawing plane? One more issue which unfortunately I didn't notice in my previous reviews: The code doesn't currently respect the rect that gets passed into WebViewImpl::paint() but rather assumes you're grabbing the entire visible area. I suspect that thumbnails don't contain scroll bars (although I could be wrong) but more generally, we should be take into account the rect we're asked to grab. I think the change should be straightforward: The intermediate canvas should be allocated to be the size of the passed rect and readPixels should only read the designated portion of the back buffer. 272954 40 wjmaclean 2010-09-01 12:56:52 -0700 (In reply to comment #39) > Unfortunately this seems to be an output-only method. You don't get a pointer to the actual pixels in the ImageBuffer. I've been looking around at the code to see if there's any other way to poke new pixels into an ImageBuffer and the only way seems to be to create a GraphicsContext around it which is essentially the code you've had up to now. OK, I've already started the revisions based on this idea. > One more issue which unfortunately I didn't notice in my previous reviews: The code doesn't currently respect the rect that gets passed into WebViewImpl::paint() but rather assumes you're grabbing the entire visible area. I suspect that thumbnails don't contain scroll bars (although I could be wrong) but more generally, we should be take into account the rect we're asked to grab. > > I think the change should be straightforward: The intermediate canvas should be allocated to be the size of the passed rect and readPixels should only read the designated portion of the back buffer. I guess if the input rect is the same size as the canvas we're OK (e.g. no scroll bars visible), but if it's smaller then we allocate an intermediate buffer. 272967 41 wjmaclean 2010-09-01 13:17:19 -0700 (In reply to comment #39) >area. I suspect that thumbnails don't contain scroll bars (although I could be wrong) but more generally, we should be take into account the rect we're asked to grab. I was just looking at my thumbnail output, and it seems (for thumbnails at least) that the scroll bars are already being clipped. Perhaps the thumbnailer takes scroll bars into account when it creates the WebCanvas bitmap? What would we do if rect was ever bigger than the canvas' bitmap? Clip it to the bitmap size? I'll play around with this shortly, once I fix my broken repository ... 273392 42 wjmaclean 2010-09-02 08:05:59 -0700 (In reply to comment #41) Does this seem reasonable? My thinking is this: the WebRect passed to WebViewImpl::paint() has x, y, width, height. Since x, y may be non-zero, we need to consider whether (x1,y1) = (x+width-1, y+height-1) // location of corner of rect satisfies x1 < rootTextureLayerSize.width() y1 < rootTextureLayerSize.height() So we do x1 = min(x1, rootTextureLayerSize.width() - 1); y1 = min(y1, rootTextureLayerSize.height() - 1); We now create resizeRect(x,y,x1-x+1,y1-y+1) [i.e. we clip rect to the rootTextureLayer] and a readback buffer of size (x1+1,y1+1). If resizeRect.width == (0, 0, bitmap.width(), bitmap.height()) then we can readback directly to the existing bitmap pixel buffer and not allocate a secondary buffer, but otherwise we allocate a temporary buffer. If we allocate a temp buffer, we read back the pixels, and draw them into the bitmap using srcRect = resizeRect dstRect = (0, 0, bitmap.width(), bitmap.height()) with re-scaling enabled. resizeRect can be computed in paint() in a platform-independent way, and passed to the platform-specific code (bitmap rects can only be determined in the platform-specific code sections). 273515 43 66402 wjmaclean 2010-09-02 13:05:00 -0700 Created attachment 66402 Patch 273522 44 wjmaclean 2010-09-02 13:12:42 -0700 (In reply to comment #42) I've uploaded a patch related to Darin's requests, and that takes into account the rect passed in to paint(). I've tried it on Linux (seems fine, but not sure how to test out the non-zer0 rect.x & rect.y case in full-blown chrome), but have so far been unable to try it on Mac due to tree-brokenness (my repo's busted). Still, I'd appreciate feedback on what's there so far. The rect management is based on my proposal in comment #42. 273781 45 66402 vangelis 2010-09-02 21:40:39 -0700 Comment on attachment 66402 Patch > > +void LayerRendererChromium::getFramebufferPixels(void *pixels, const IntSize& size) This method should take an IntRect as it shouldn't always assume that we're reading starting from (0,0) > +{ > + ASSERT(size == rootLayerTextureSize()); > + > + if (!pixels) > + return; > + > + makeContextCurrent(); > + > + GLC(glReadPixels(0, 0, size.width(), size.height(), > + GL_RGBA, GL_UNSIGNED_BYTE, pixels)); > + > + // Flip pixels vertically. > + const int rowBytes = 4 * size.width(); > + OwnArrayPtr<unsigned char> lineTemp(new unsigned char[rowBytes]); > + for (int row1 = 0, row2 = size.height() - 1; row1 < size.height() / 2; ++row1, --row2) { > + unsigned char* ptr1 = static_cast<unsigned char*>(pixels) + row1 * rowBytes; > + unsigned char* ptr2 = static_cast<unsigned char*>(pixels) + row2 * rowBytes; > + > + memcpy(lineTemp.get(), ptr1, rowBytes); > + memcpy(ptr1, ptr2, rowBytes); > + memcpy(ptr2, lineTemp.get(), rowBytes); > + } > +} > + > + > + // If a canvas was passed in, we use it to grab a copy of the > + // freshly-rendered pixels. > + if (canvas) { > + // Clip rect to the confines of the rootLayerTexture. > + int xMax = min(rect.x + rect.width - 1, m_layerRenderer->rootLayerTextureSize().width() - 1); > + int yMax = min(rect.y + rect.height - 1, m_layerRenderer->rootLayerTextureSize().height() - 1); > + WebRect resizeRect(rect.x, rect.y, xMax - rect.x + 1, yMax - rect.y + 1); A cleaner way to do this would be to create an IntRect out of WebRect and call IntRect::intersect() with the rect of rootLayerTextureSize. > + doPixelReadbackToCanvas(canvas, resizeRect); > + } > + > + m_layerRenderer->present(); // Do final display by swapping buffers. > } > #endif > } > > +#if USE(ACCELERATED_COMPOSITING) > +#if PLATFORM(SKIA) > +static inline void clearSkBitmap(const SkBitmap& bitmap) > +{ > + bitmap.eraseColor(SkColorSetARGB(0, 0, 0, 0)); > +} > + > +void WebViewImpl::doPixelReadbackToCanvas(WebCanvas* canvas, WebRect& rect) > +{ > + ASSERT((rect.x + rect.width -1) < m_layerRenderer->rootLayerTextureSize().width() > + && (rect.y + rect.height -1) < m_layerRenderer->rootLayerTextureSize().height()); If you continue using IntRect, you can call IntRect::right and IntRect::bottom instead of doing the math. But I think what you really want to ASSERT is rect.intersect(rootLayerRect) == rect > + > + void* pixels = 0; > + const SkBitmap bitmap = canvas->getDevice()->accessBitmap(false); > + if (bitmap.config() == SkBitmap::kARGB_8888_Config) { > + WebRect bitmapRect(0, 0, bitmap.width(), bitmap.height()); > + IntSize size(bitmapRect.width, bitmapRect.height); > + > + SkAutoLockPixels bitmapLock(bitmap); > + > + if (rect == bitmapRect) { > + pixels = bitmap.getPixels(); > + m_layerRenderer->getFramebufferPixels(pixels, size); > + } else { > + IntSize resize(rect.x + rect.width, rect.y + rect.height); > + > + // Create temp bitmap of correct size to copy pixels into. > + skia::PlatformCanvas canvasResize; > + if (canvasResize.initialize(resize.width(), resize.height(), true)) { > + SkBitmap bitmapResize = canvasResize.getDevice()->accessBitmap(false); > + pixels = bitmapResize.getPixels(); > + m_layerRenderer->getFramebufferPixels(pixels, resize); It seems like you're always reading from (0,0) up to the width you need. Ideally you want to read only the rect you were asked to render. Alternatively, you can eliminate a lot of the trimming logic and always read the entire backbuffer and then use the srcRect in drawBitmapRect to specify which part you want out of it. I think though that reading only the region you need is more elegant. > + SkIRect srcRect; > + srcRect.set(rect.x, rect.y, rect.width, rect.height); > + SkRect dstRect = SkRect::MakeWH(bitmap.width(), bitmap.height()); > + canvas->drawBitmapRect(bitmapResize, &srcRect, dstRect, 0); > + } else { > + clearSkBitmap(bitmap); > + ASSERT_NOT_REACHED(); > + } > + } > + } else { > + clearSkBitmap(bitmap); > + ASSERT_NOT_REACHED(); > + } > +} > + > +#elif PLATFORM(CG) > +static inline void clearCGBitmap(const CGContextRef& bitmap) > +{ > + CGContextClearRect(bitmap, > + CGRectMake(0, 0, CGBitmapContextGetWidth(bitmap), CGBitmapContextGetHeight(bitmap))); > +} > + > +void WebViewImpl::doPixelReadbackToCanvas(WebCanvas* canvas, WebRect& rect) > +{ > + ASSERT((rect.x + rect.width -1) < m_layerRenderer->rootLayerTextureSize().width() > + && (rect.y + rect.height -1) < m_layerRenderer->rootLayerTextureSize().height()); > + > + void* pixels = 0; > + CGContextRef bitmap = reinterpret_cast<CGContextRef>(canvas); > + WebRect bitmapRect(0, 0, CGBitmapContextGetWidth(bitmap), CGBitmapContextGetHeight(bitmap)); > + IntSize size(bitmapRect.width, bitmapRect.height); > + if (CGBitmapContextGetRowBytes(bitmap) == 4 * bitmapRect.width) { > + if (rect == bitmapRect) { > + pixels = CGBitmapContextGetData(bitmap); > + m_layerRenderer->getFramebufferPixels(pixels, size); > + } else { > + IntSize resize(rect.x + rect.width, rect.y + rect.height); > + > + // Create temp bitmap of same size as rendered layer to copy pixels into. > + CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB(); > + CGContextRef bitmapResize = CGBitmapContextCreate(0, resize.width(), resize.height(), > + 8, 4 * resize.width(), colorSpace, > + kCGImageAlphaPremultipliedLast); > + if (bitmapResize) { > + pixels = CGBitmapContextGetData(bitmapResize); > + m_layerRenderer->getFramebufferPixels(pixels, resize); > + > + // Copy bitmap back to input bitmap. The image is inverted according to CG, > + // so set up the appropriate transform to invert vertical axis and move origin > + // to bottom left. > + CGContextSaveGState(bitmap); > + CGContextTranslateCTM(bitmap, 0, bitmapRect.height); > + CGContextScaleCTM(bitmap, 1.0, -1.0); > + CGContextDrawImage(bitmap, > + CGRectMake(bitmapRect.x, bitmapRect.y, bitmapRect.width, bitmapRect.height), > + CGBitmapContextCreateImage(bitmapResize)); > + CGContextRestoreGState(bitmap); > + } else { > + clearCGBitmap(bitmap); > + ASSERT_NOT_REACHED(); > + } > + } > + } else { > + clearCGBitmap(bitmap); > + ASSERT_NOT_REACHED(); > + } > +} > +#else > +#error Must port to your platform. > +#endif > + > +#endif > + > // FIXME: m_currentInputEvent should be removed once ChromeClient::show() can > // get the current-event information from WebCore. > const WebInputEvent* WebViewImpl::m_currentInputEvent = 0; > diff --git a/WebKit/chromium/src/WebViewImpl.h b/WebKit/chromium/src/WebViewImpl.h > index c29612123f4514c94dd7d970c73114a4beeec355..fd75a20117f9ffdb98223c9498d4ee7ae98643fd 100644 > --- a/WebKit/chromium/src/WebViewImpl.h > +++ b/WebKit/chromium/src/WebViewImpl.h > @@ -386,6 +386,7 @@ private: > #if USE(ACCELERATED_COMPOSITING) > void setIsAcceleratedCompositingActive(bool); > void updateRootLayerContents(const WebRect&); > + void doPixelReadbackToCanvas(WebCanvas*, WebRect&); > #endif > > WebViewClient* m_client; 273968 46 66505 wjmaclean 2010-09-03 09:08:19 -0700 Created attachment 66505 Patch 273971 47 wjmaclean 2010-09-03 09:13:43 -0700 (In reply to comment #45) > > A cleaner way to do this would be to create an IntRect out of WebRect and call IntRect::intersect() with the rect of rootLayerTextureSize. Thanks for suggesting this. I had been staying with WebRect only because that's what was used in paint(), and I thought it might be preferred. Why do we have WebRect? > > If you continue using IntRect, you can call IntRect::right and IntRect::bottom instead of doing the math. But I think what you really want to > ASSERT is rect.intersect(rootLayerRect) == rect So far I don't have a rootLayerRect around so I am still using bottom() and right(). Is there a strong preference for having rootLayerTextureRect() instead of rootLayerTextureSize()? > It seems like you're always reading from (0,0) up to the width you need. Ideally you want to read only the rect you were asked to render. Alternatively, you can eliminate a lot > of the trimming logic and always read the entire backbuffer and then use the srcRect in drawBitmapRect to specify which part you want out of it. I think though that reading only the region you need is more elegant. D'oh! It's been so long since I started this that I started assuming glReadPixel() require (0,0) as the start point ... I've fixed this. 274007 48 66505 vangelis 2010-09-03 10:09:51 -0700 Comment on attachment 66505 Patch > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index 44b15f411d30c6fef6233acc6ae7a7eede7eb10f..9926e8d0ab4b023aba4e4775050263441f55d62e 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,22 @@ > +2010-09-02 W. James MacLean <wjmaclean@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + [chromium] Thumbnails not generated for GPU Rendered Pages > + https://bugs.webkit.org/show_bug.cgi?id=44127 > + > + Replicates existing functionality, use existing tests. > + > + Adds pixel-readback for GPU composited pages to allow for thumbnailing, > + printing and other services to work with GPU rendered pages. > + > + * platform/graphics/chromium/LayerRendererChromium.cpp: > + (WebCore::LayerRendererChromium::drawLayers): > + (WebCore::LayerRendererChromium::present): > + (WebCore::LayerRendererChromium::getFramebufferPixels): > + * platform/graphics/chromium/LayerRendererChromium.h: > + (WebCore::LayerRendererChromium::rootLayerTextureSize): > + > 2010-09-02 Andreas Kling <andreas.kling@nokia.com> > > Rubber-stamped by Simon Hausmann. > diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > index 50338d2d5f7324e5a119c509190dfef8698b1769..5c3c0b1b316564f4dad5baef0feb458f11fee150 100644 > --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp > @@ -39,6 +39,7 @@ > #include "GLES2Context.h" > #include "LayerChromium.h" > #include "NotImplemented.h" > +#include <wtf/OwnArrayPtr.h> > #if PLATFORM(SKIA) > #include "NativeImageSkia.h" > #include "PlatformContextSkia.h" > @@ -321,11 +322,41 @@ void LayerRendererChromium::drawLayers(const IntRect& updateRect, const IntRect& > > GLC(glDisable(GL_SCISSOR_TEST)); > > + glFlush(); > +} > + > +void LayerRendererChromium::present() > +{ > m_gles2Context->swapBuffers(); > > m_needsDisplay = false; > } > > +void LayerRendererChromium::getFramebufferPixels(void *pixels, const IntRect& rect) > +{ > + ASSERT(rect.size() == rootLayerTextureSize()); Shouldn't you be asserting that it's not larger than the rootLayerTextureSize? It won't always be equal to it, right? > + > + if (!pixels) > + return; > + > + makeContextCurrent(); > + > + GLC(glReadPixels(rect.x(), rect.y(), rect.width(), rect.height(), > + GL_RGBA, GL_UNSIGNED_BYTE, pixels)); > + > + // Flip pixels vertically. > + const int rowBytes = 4 * rect.width(); > + OwnArrayPtr<unsigned char> lineTemp(new unsigned char[rowBytes]); > + for (int row1 = 0, row2 = rect.height() - 1; row1 < rect.height() / 2; ++row1, --row2) { > + unsigned char* ptr1 = static_cast<unsigned char*>(pixels) + row1 * rowBytes; > + unsigned char* ptr2 = static_cast<unsigned char*>(pixels) + row2 * rowBytes; > + > + memcpy(lineTemp.get(), ptr1, rowBytes); > + memcpy(ptr1, ptr2, rowBytes); > + memcpy(ptr2, lineTemp.get(), rowBytes); > + } > +} > + > // FIXME: This method should eventually be replaced by a proper texture manager. > unsigned LayerRendererChromium::createLayerTexture() > { > diff --git a/WebCore/platform/graphics/chromium/LayerRendererChromium.h b/WebCore/platform/graphics/chromium/LayerRendererChromium.h > index 8f44afebd0a2c7b475d04ba48723f1cdc5455091..ffe41423d53e3f540e710233faf2a0f81562ce57 100644 > --- a/WebCore/platform/graphics/chromium/LayerRendererChromium.h > +++ b/WebCore/platform/graphics/chromium/LayerRendererChromium.h > @@ -64,6 +64,7 @@ public: > // Updates the contents of the root layer that fall inside the updateRect and recomposites > // all the layers. > void drawLayers(const IntRect& updateRect, const IntRect& visibleRect, const IntRect& contentRect, const IntPoint& scrollPosition); > + void present(); // Perform buffer swap to present rendered buffer. > > void setRootLayer(PassRefPtr<LayerChromium> layer) { m_rootLayer = layer; } > LayerChromium* rootLayer() { return m_rootLayer.get(); } > @@ -90,6 +91,9 @@ public: > const ContentLayerChromium::SharedValues* contentLayerSharedValues() const { return m_contentLayerSharedValues.get(); } > const CanvasLayerChromium::SharedValues* canvasLayerSharedValues() const { return m_canvasLayerSharedValues.get(); } > > + IntSize rootLayerTextureSize() const { return IntSize(m_rootLayerTextureWidth, m_rootLayerTextureHeight); } > + void getFramebufferPixels(void *pixels, const IntRect& rect); > + > private: > void updateLayersRecursive(LayerChromium* layer, const TransformationMatrix& parentMatrix, float opacity); > > diff --git a/WebKit/chromium/ChangeLog b/WebKit/chromium/ChangeLog > index 527e8efccae39045fd985ded3bf20d7166afc69d..65f0e9d4d9a42d16bdccd97988b4abb8b19227ab 100644 > --- a/WebKit/chromium/ChangeLog > +++ b/WebKit/chromium/ChangeLog > @@ -1,3 +1,23 @@ > +2010-09-02 W. James MacLean <wjmaclean@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + [chromium] Thumbnails not generated for GPU Rendered Pages > + https://bugs.webkit.org/show_bug.cgi?id=44127 > + > + Modified WebViewImpl::paint() to detect non-null canvas pointers when > + accelerated compositing is active, and instead fills the pixel buffer > + from the GPU framebuffer. Includes re-scaling support when provided > + canvas does not match size of current render layer. Limits pixel > + readback to rect passed to paint(), clipped by size of rootLayerTexture. > + > + * src/WebViewImpl.cpp: > + (WebKit::WebViewImpl::paint): > + (WebKit::clearSkBitmap): > + (WebKit::WebViewImpl::doPixelReadbackToCanvas): > + (WebKit::clearCGBitmap): > + * src/WebViewImpl.h: > + > 2010-09-02 Ilya Sherman <isherman@google.com> > > Reviewed by Eric Seidel. > diff --git a/WebKit/chromium/src/WebViewImpl.cpp b/WebKit/chromium/src/WebViewImpl.cpp > index 4b129d694b1f112f27b21ae724db67a68a74e02a..d10b2a8f1acbcbe8493bca580de81e319f3fa952 100644 > --- a/WebKit/chromium/src/WebViewImpl.cpp > +++ b/WebKit/chromium/src/WebViewImpl.cpp > @@ -64,7 +64,6 @@ > #include "HTMLNames.h" > #include "Image.h" > #include "InspectorController.h" > -#include "IntRect.h" > #include "KeyboardCodes.h" > #include "KeyboardEvent.h" > #include "MIMETypeRegistry.h" > @@ -115,6 +114,10 @@ > #include "WebViewClient.h" > #include "wtf/OwnPtr.h" > > +#if PLATFORM(CG) > +#include <CoreGraphics/CGContext.h> > +#endif > + > #if OS(WINDOWS) > #include "RenderThemeChromiumWin.h" > #else > @@ -952,6 +955,7 @@ void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect) > webframe->paint(canvas, rect); > #if USE(ACCELERATED_COMPOSITING) > } else { > + nit: please remove the added newline > // Draw the contents of the root layer. > updateRootLayerContents(rect); > > @@ -968,10 +972,118 @@ void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect) > > // Ask the layer compositor to redraw all the layers. > m_layerRenderer->drawLayers(rect, visibleRect, contentRect, IntPoint(view->scrollX(), view->scrollY())); > + > + // If a canvas was passed in, we use it to grab a copy of the > + // freshly-rendered pixels. > + if (canvas) { > + // Clip rect to the confines of the rootLayerTexture. > + IntRect resizeRect(rect.x, rect.y, rect.width, rect.height); > + resizeRect.intersect(IntRect(IntPoint(), m_layerRenderer->rootLayerTextureSize())); > + doPixelReadbackToCanvas(canvas, resizeRect); > + } > + > + m_layerRenderer->present(); // Do final display by swapping buffers. > } > #endif > } > > +#if USE(ACCELERATED_COMPOSITING) > +#if PLATFORM(SKIA) > +static inline void clearSkBitmap(const SkBitmap& bitmap) > +{ > + bitmap.eraseColor(SkColorSetARGB(0, 0, 0, 0)); > +} > + > +void WebViewImpl::doPixelReadbackToCanvas(WebCanvas* canvas, IntRect& rect) > +{ > + ASSERT(rect.right() <= m_layerRenderer->rootLayerTextureSize().width() > + && rect.bottom() <= m_layerRenderer->rootLayerTextureSize().height()); > + > + void* pixels = 0; > + const SkBitmap bitmap = canvas->getDevice()->accessBitmap(false); > + if (bitmap.config() == SkBitmap::kARGB_8888_Config) { > + IntRect bitmapRect(0, 0, bitmap.width(), bitmap.height()); > + > + SkAutoLockPixels bitmapLock(bitmap); > + The SkAutoLockPixels should move inside the if (rect==bitmapRect) > + if (rect == bitmapRect) { > + pixels = bitmap.getPixels(); > + m_layerRenderer->getFramebufferPixels(pixels, rect); > + } else { > + // Create temp bitmap of correct size to copy pixels into. > + skia::PlatformCanvas canvasResize; > + if (canvasResize.initialize(rect.width(), rect.height(), true)) { > + SkBitmap bitmapResize = canvasResize.getDevice()->accessBitmap(false); > + pixels = bitmapResize.getPixels(); > + m_layerRenderer->getFramebufferPixels(pixels, rect); > + SkIRect srcRect(rect); I think at this point srcRect should be (0, 0, rect.width(), rect.height()) > + SkRect dstRect(bitmapRect); > + canvas->drawBitmapRect(bitmapResize, &srcRect, dstRect, 0); > + } else { > + clearSkBitmap(bitmap); > + ASSERT_NOT_REACHED(); > + } > + } > + } else { > + clearSkBitmap(bitmap); > + ASSERT_NOT_REACHED(); > + } > +} > + > +#elif PLATFORM(CG) > +static inline void clearCGBitmap(const CGContextRef& bitmap) > +{ > + CGContextClearRect(bitmap, > + CGRectMake(0, 0, CGBitmapContextGetWidth(bitmap), CGBitmapContextGetHeight(bitmap))); > +} > + > +void WebViewImpl::doPixelReadbackToCanvas(WebCanvas* canvas, IntRect& rect) > +{ > + ASSERT(rect.right() <= m_layerRenderer->rootLayerTextureSize().width() > + && rect.bottom() <= m_layerRenderer->rootLayerTextureSize().height()); > + > + void* pixels = 0; > + CGContextRef bitmap = reinterpret_cast<CGContextRef>(canvas); > + IntRect bitmapRect(0, 0, CGBitmapContextGetWidth(bitmap), CGBitmapContextGetHeight(bitmap)); > + if (CGBitmapContextGetRowBytes(bitmap) == 4 * bitmapRect.width()) { > + if (rect == bitmapRect) { > + pixels = CGBitmapContextGetData(bitmap); > + m_layerRenderer->getFramebufferPixels(pixels, rect); > + } else { > + // Create temp bitmap of same size as rendered layer to copy pixels into. > + CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB(); > + CGContextRef bitmapResize = CGBitmapContextCreate(0, rect.width(), rect.height(), > + 8, 4 * rect.width(), colorSpace, > + kCGImageAlphaPremultipliedLast); > + if (bitmapResize) { > + pixels = CGBitmapContextGetData(bitmapResize); > + m_layerRenderer->getFramebufferPixels(pixels, rect); > + > + // Copy bitmap back to input bitmap. The image is inverted according to CG, > + // so set up the appropriate transform to invert vertical axis and move origin > + // to bottom left. > + CGContextSaveGState(bitmap); > + CGContextTranslateCTM(bitmap, 0, bitmapRect.height()); > + CGContextScaleCTM(bitmap, 1.0, -1.0); > + CGContextDrawImage(bitmap, bitmapRect, > + CGBitmapContextCreateImage(bitmapResize)); > + CGContextRestoreGState(bitmap); > + } else { > + clearCGBitmap(bitmap); > + ASSERT_NOT_REACHED(); > + } > + } > + } else { > + clearCGBitmap(bitmap); > + ASSERT_NOT_REACHED(); > + } > +} > +#else > +#error Must port to your platform. > +#endif > + > +#endif > + > // FIXME: m_currentInputEvent should be removed once ChromeClient::show() can > // get the current-event information from WebCore. > const WebInputEvent* WebViewImpl::m_currentInputEvent = 0; > diff --git a/WebKit/chromium/src/WebViewImpl.h b/WebKit/chromium/src/WebViewImpl.h > index c29612123f4514c94dd7d970c73114a4beeec355..67cce0163e0a4f5551a2e608dee26305b5c55766 100644 > --- a/WebKit/chromium/src/WebViewImpl.h > +++ b/WebKit/chromium/src/WebViewImpl.h > @@ -45,6 +45,7 @@ > #include "EditorClientImpl.h" > #include "GraphicsLayer.h" > #include "InspectorClientImpl.h" > +#include <IntRect.h> > #include "LayerRendererChromium.h" > #include "NotificationPresenterImpl.h" > #include "SpeechInputClientImpl.h" > @@ -386,6 +387,7 @@ private: > #if USE(ACCELERATED_COMPOSITING) > void setIsAcceleratedCompositingActive(bool); > void updateRootLayerContents(const WebRect&); > + void doPixelReadbackToCanvas(WebCanvas*, WebCore::IntRect&); const WebCore::IntRect& ? > #endif > > WebViewClient* m_client; 274036 49 66521 wjmaclean 2010-09-03 10:59:34 -0700 Created attachment 66521 Patch 274040 50 wjmaclean 2010-09-03 11:04:04 -0700 (In reply to comment #48) > > + ASSERT(rect.size() == rootLayerTextureSize()); > > Shouldn't you be asserting that it's not larger than the rootLayerTextureSize? It won't always be equal to it, right? Correct, thanks. > > #if USE(ACCELERATED_COMPOSITING) > > } else { > > + > > nit: please remove the added newline Done. > The SkAutoLockPixels should move inside the if (rect==bitmapRect) OK. I thought it might be necessary for the drawBitmapRect call too. > > const WebCore::IntRect& ? Yup! Could I ask if you can remove the excess code when you post a comment like this? Without coloured highlighting in the reply box (when I'm replying to your comments), it's hard to separate your comments from the code (I'm concerned about missing a comment somewhere). 274043 51 wjmaclean 2010-09-03 11:09:07 -0700 BTW, this latest patch has yet to be tested on Linux or Mac (I can't do GLX 1.3 over NXclient from home). Will do this Monday morning. 274325 52 66521 vangelis 2010-09-03 19:12:32 -0700 Comment on attachment 66521 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=66521&action=prettypatch > WebKit/chromium/src/WebViewImpl.cpp:1017 > + SkIRect srcRect(IntRect(IntPoint(), rect.size())); It was pointed out to me that the semantics of the WebViewImpl::paint() method call for the rect to be painted on the WebCanvas with the same offset it was grabbed from. In other words, the dest rect must be the same as the source rect. Sorry about the confusion! 275236 53 66755 wjmaclean 2010-09-07 13:15:08 -0700 Created attachment 66755 Patch 275244 54 wjmaclean 2010-09-07 13:19:22 -0700 (In reply to comment #52) > (From update of attachment 66521 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=66521&action=prettypatch > > > WebKit/chromium/src/WebViewImpl.cpp:1017 > > + SkIRect srcRect(IntRect(IntPoint(), rect.size())); > It was pointed out to me that the semantics of the WebViewImpl::paint() method call for the rect to be painted on the WebCanvas with the same offset it was grabbed from. In other words, the dest rect must be the same as the source rect. Sorry about the confusion! Fixed. The line of code you quote above needs to stay as is, as srcRect refers to the temporary bitmap we allocate to handle the (potential) size difference, but the next line (dstRect) changes. I've also put the vertical-flip code inside a PLATFORM(SKIA) block since 1) CG doesn't need it flipped, so if we leave it in a secondary transform is required, 2) the secondary transform screws up if 'rect' is a sub-set of the canvas, and 3) and it's faster for Mac. 275336 55 66755 vangelis 2010-09-07 15:24:16 -0700 Comment on attachment 66755 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=66755&action=prettypatch > WebCore/ChangeLog:10 > + printing and other services to work with GPU rendered pages. Just curious, does any of the pages that the thumbnailing tests use trigger the compositor? If not, we should probably add one just to make sure this functionality doesn't break over time. > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:349 > + // Flip pixels vertically. If flipping the image is only necessary when stuffing the pixels into a skia canvas then it occurs to me that this isn't the right spot for it. This function knows nothing about who's going to be using the pixels as it writes straight into a void* memory address. The flipping, if necessary, needs to happen by the caller. Seems to me that in the Skia case it would be cleanest if you always create a temporary canvas and use a SkCanvas transform to do the flipping as you draw from the temp canvas into the WebCanvas. If you think that's a reasonable avenue then it might be possible to merge the two platform paths in the following way (which I think is what Darin was suggesting in the first place): 1. Create an ImageBuffer object for your temporary storage. Create an ImageData object to go along with it. 2. Get a CanvasPixelArray out of the ImageData object and use it to store the pixels you get out of the getFrameBufferPixels call. 3. Use, across all platforms, drawImageBuffer() to copy the temporary image onto the GraphicsContext that WebViewImpl::paint gets passed in. On the surface of it it seems that this should work without any platform specific code... but maybe I'm not seeing something here. > WebKit/chromium/src/WebViewImpl.cpp:1062 > + // to bottom left. The comment above is no longer valid as you're not doing an inversion here anymore. You don't need to save and restore the state either. 275847 56 wjmaclean 2010-09-08 08:18:24 -0700 (In reply to comment #55) > (From update of attachment 66755 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=66755&action=prettypatch > > > WebCore/ChangeLog:10 > > + printing and other services to work with GPU rendered pages. > Just curious, does any of the pages that the thumbnailing tests use trigger the compositor? If not, we should probably add one just to make sure this functionality doesn't break over time. I don't think thumbnails are tested directly in WebKit (there's a chromium unit test, but it's currently disabled). I'm happy to add in a test that requires the compositor, but haven't the first idea how to do it. Any thoughts as to were this functionality gets tested? > > WebCore/platform/graphics/chromium/LayerRendererChromium.cpp:349 > > + // Flip pixels vertically. > If flipping the image is only necessary when stuffing the pixels into a skia canvas then it occurs to me that this isn't the right spot for it. This function knows nothing > about who's going to be using the pixels as it writes straight into a void* memory address. The flipping, if necessary, needs to happen by the caller. Seems to me that in the Skia case it would be cleanest if you always create a temporary canvas and use a SkCanvas transform to do the flipping as you draw from the temp canvas into the WebCanvas. It could be handled in WebViewImpl, in the platform-specific code for Skia? > If you think that's a reasonable avenue then it might be possible to merge the two platform paths in the following way (which I think is what Darin was suggesting in the first place): > > 1. Create an ImageBuffer object for your temporary storage. Create an ImageData object to go along with it. > 2. Get a CanvasPixelArray out of the ImageData object and use it to store the pixels you get out of the getFrameBufferPixels call. > 3. Use, across all platforms, drawImageBuffer() to copy the temporary image onto the GraphicsContext that WebViewImpl::paint gets passed in. > > On the surface of it it seems that this should work without any platform specific code... but maybe I'm not seeing something here. This will work, but: 1) We will still need a few lines of platform-specific code to create the graphics context, 2) since there is no way to get a (writable) pointer to the underlying ImageBuffer pixels, as you suggest we need to create an ImageData object in addition to the ImageBuffer (now we have two additional buffer allocations/deallocations), and 3) copy from the GPU to the ImageData object, then copy to the ImageBuffer, then draw to the original canvas object. In the event that the input rect and canvas are the same size and smaller than the root layer texture, then we currently need only one pixel transfer for Mac, two for Skia (due to the vertical flip) and no allocation/deallocation of intermediate buffers. I suspect this condition is true in most (if not all) cases. So the platform-specific code, if not pretty, is probably much more efficient. That being said, I'm happy to do the platform independent code if that's what is preferred. Darin, do you have any thoughts on this? I'll upload a new patch as soon as this is decided. > > WebKit/chromium/src/WebViewImpl.cpp:1062 > > + // to bottom left. > The comment above is no longer valid as you're not doing an inversion here anymore. You don't need to save and restore the state either. Thanks, I missed the comment. I wasn't sure about the context save/restore, but have now removed these. 275922 57 66911 wjmaclean 2010-09-08 10:34:12 -0700 Created attachment 66911 Patch 275926 58 wjmaclean 2010-09-08 10:40:05 -0700 This new patch stills keeps the platform-specific code in place (I won't change this until I hear back for sure about making platform-independent), but it does (1) move the Skia image flip into WebViewImpl (using Skia transforms if a temp buffer is already in use), and (2) a conditional compile define to allow easy switching to force the Skia temp buffer (I'd like suggestions for a better name for the #define name - is there a standard for naming these). We don't have to keep (2), but for now it highlights the difference between always using the temporary Skia buffer versus trying to use only the existing buffer. It also fixes the minor CG issues in the previous comments. 276212 59 66911 vangelis 2010-09-08 17:36:47 -0700 Comment on attachment 66911 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=66911&action=prettypatch You make a good point about the extra allocations and unnecessary copies that would be introduced if we used an intermediate ImageBuffer and ImageData to store the pixels. However, since this code won't be called too often (only for thumbnailing and printing?) it's probably not worth worrying about it. WebKit allocates and destroys GraphicsContexts on a whim every time it renders a page.... I think the reduced code size and complexity will more than make up for it. > WebKit/chromium/src/WebViewImpl.cpp:117 > +#include <wtf/OwnArrayPtr.h> WK uses quotes instead of angle brackets for includes. > WebKit/chromium/src/WebViewImpl.cpp:998 > + bitmap.eraseColor(SkColorSetARGB(0, 0, 0, 0)); Since this is a one-liner, it's probably better to just call it directly instead of making a function for it. > WebKit/chromium/src/WebViewImpl.cpp:1046 > + clearSkBitmap(bitmap); Do we really have to worry about the canvasResize not being able to initialize? What would make it fail? Maybe the else path can be removed. > WebKit/chromium/src/WebViewImpl.cpp:1061 > + CGContextClearRect(bitmap, same as above. probably not worth making a separate function for it. > WebKit/chromium/src/WebViewImpl.cpp:1090 > + clearCGBitmap(bitmap); Again, do we have to worry about the failing to create the temporary bitmap? > WebKit/chromium/src/WebViewImpl.h:48 > +#include <IntRect.h> Quotes instead of angle brackets 276213 60 abarth 2010-09-08 17:41:45 -0700 > (From update of attachment 66911 [details]) > > WebKit/chromium/src/WebViewImpl.cpp:117 > > +#include <wtf/OwnArrayPtr.h> > WK uses quotes instead of angle brackets for includes. Except for stuff in other frameworks. In particular, we use <> for grabbing things out of WTF (check out Document.h for examples). 276614 61 67071 wjmaclean 2010-09-09 11:19:32 -0700 Created attachment 67071 Patch 276619 62 wjmaclean 2010-09-09 11:23:12 -0700 This patch represents a re-design of the thumbnail read-back code. It is, so far as possible, platform-independent (although a bit of platform-dependent code is required to set up the graphics context and to get the bitmap height for vertical flipping). The patch assumes that GraphicsContext::drawImageBuffer() is capable of detecting (and ignoring) draw requests if the input canvas/bitmap format is not RGBA. 276642 63 67071 vangelis 2010-09-09 11:54:04 -0700 Comment on attachment 67071 Patch I like the new clean look! Thanks for taking the time to make the change. View in context: https://bugs.webkit.org/attachment.cgi?id=67071&action=prettypatch > WebKit/chromium/src/WebViewImpl.cpp:969 > +#error Must port to your platform. Looks like other parts of the code (e.g. WebFrameImpl::paint()) call notImplemented() instead of giving a compiler error. Maybe follow that precedent here? > WebKit/chromium/src/WebViewImpl.cpp:978 > + gc.translate(FloatSize(0.0f, bitmapHeight)); Isn't the flip necessary for only one of the two platforms? 276650 64 wjmaclean 2010-09-09 12:10:13 -0700 (In reply to comment #63) > (From update of attachment 67071 [details]) > I like the new clean look! Thanks for taking the time to make the change. No problem! > View in context: https://bugs.webkit.org/attachment.cgi?id=67071&action=prettypatch > > > WebKit/chromium/src/WebViewImpl.cpp:969 > > +#error Must port to your platform. > Looks like other parts of the code (e.g. WebFrameImpl::paint()) call notImplemented() instead of giving a compiler error. Maybe follow that precedent here? Sure. > > WebKit/chromium/src/WebViewImpl.cpp:978 > > + gc.translate(FloatSize(0.0f, bitmapHeight)); > Isn't the flip necessary for only one of the two platforms? I've tried it on both Mac & Linux (expecting Mac not to need the flip), but I'm guessing that something inside GraphicsContext must unflip the flip for Mac, so that both platforms have the same interface. I'm verifying this all works properly for rect not equal to the texture layer rect, and will re-upload a patch when I have done so, and made the other change. 276706 65 67085 wjmaclean 2010-09-09 13:28:07 -0700 Created attachment 67085 Patch 276711 66 wjmaclean 2010-09-09 13:31:08 -0700 It took a little more work to get this correct for rect's that don't match the texture layer rect, but I've now tested this on a variety of rect sizes and locations, and it seems good. 276741 67 67085 vangelis 2010-09-09 14:02:39 -0700 Comment on attachment 67085 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=67085&action=prettypatch > WebKit/chromium/src/WebViewImpl.cpp:971 > + // Compute rect to sample from in inverted GPU buffer. typo: in inverted > WebKit/chromium/src/WebViewImpl.cpp:972 > + IntRect invertRect(rect.x(), bitmapHeight - (rect.y() + rect.height()), rect.width(), rect.height()); rect.y + rect.height I believe is returned by rect.bottom() . I'm curious though, isn't adding a Y offset here equivalent to some gc.translate further down? It seems that you would only need one of the two, with the appropriate values. I'd venture to say maybe replace your current gc.translate by a gc.translate(FloatSize(0, rect.bottom()) but use the original rect? 276905 68 wjmaclean 2010-09-09 18:14:07 -0700 (In reply to comment #67) > (From update of attachment 67085 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=67085&action=prettypatch > > > WebKit/chromium/src/WebViewImpl.cpp:971 > > + // Compute rect to sample from in inverted GPU buffer. > typo: in inverted Thanks, will fix. > > WebKit/chromium/src/WebViewImpl.cpp:972 > > + IntRect invertRect(rect.x(), bitmapHeight - (rect.y() + rect.height()), rect.width(), rect.height()); > rect.y + rect.height I believe is returned by rect.bottom() . I'm curious though, isn't adding a Y offset here equivalent to some gc.translate further down? It seems that you would only need one of the two, with the appropriate values. I'd venture to say maybe replace your current gc.translate by a gc.translate(FloatSize(0, rect.bottom()) but use the original rect? Yes, I could use rect.bottom(). Note that the expression above changes the sign of rect.y() also. Assuming that the value (x,y)=(0,0) in the WebRect passed into paint() is meant to be top-left (with y values increasing downward), then it will be necessary to transform the rect *before* passing it to getFramebufferPixels, as the GPU is mapping (0,0) to the bottom-left, with y-values increasing upwards. If rect is (0,0,root_texture_width, root_texture_height) then this transformation doesn't change the rect, and then the gc transforms invert what is returned. But if rect is anything else, then it must be transformed before the pixels are read back, and the returned bitmap must be transformed again when writing into the gc to flip it vertically. I tried it using just the original rect for the gc writeback, but it seems the draw function wants to transform the destRect coordinates prior to doing the draw. It seems obvious that rect must be transformed before the gpu read-back can be done. If glReadPixels() allowed one to flip the pixels vertically during the read it would help, but it doesn't. Does that make sense? 276924 69 67085 vangelis 2010-09-09 18:35:48 -0700 Comment on attachment 67085 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=67085&action=prettypatch > WebKit/chromium/src/WebViewImpl.cpp:972 > + IntRect invertRect(rect.x(), bitmapHeight - (rect.y() + rect.height()), rect.width(), rect.height()); Ah, ok, I think I see it now! Thanks for the detailed explanation. 277173 70 67178 wjmaclean 2010-09-10 07:27:23 -0700 Created attachment 67178 Patch 278261 71 67419 wjmaclean 2010-09-13 09:52:42 -0700 Created attachment 67419 Patch 278264 72 wjmaclean 2010-09-13 09:55:23 -0700 Revised to accommodate Nat's patch. The merge seemed to think there should be no glFlush() at the end of drawLayers() ... is this OK? (Seems to work on Linux/Mac.) 278336 73 67419 fishd 2010-09-13 11:31:05 -0700 Comment on attachment 67419 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=67419&action=prettypatch > WebKit/chromium/src/WebViewImpl.cpp:980 > + OwnPtr<ImageBuffer> imgBuffer(ImageBuffer::create(rect.size())); nit: imgBuffer -> imageBuffer, imgData -> imageData webkit style prefers spelling out variable names > WebKit/chromium/src/WebViewImpl.cpp:1006 > + IntRect resizeRect(rect.x, rect.y, rect.width, rect.height); nit: you can also just write: IntRect resizeRect(rect); there is an implicit conversion operator from WebRect to IntRect R=me otherwise 278351 74 67444 wjmaclean 2010-09-13 11:46:41 -0700 Created attachment 67444 Patch 278727 75 67444 commit-queue 2010-09-13 22:26:48 -0700 Comment on attachment 67444 Patch Clearing flags on attachment: 67444 Committed r67445: <http://trac.webkit.org/changeset/67445> 278728 76 commit-queue 2010-09-13 22:26:57 -0700 All reviewed patches have been landed. Closing bug. 278747 77 webkit.review.bot 2010-09-13 23:51:00 -0700 http://trac.webkit.org/changeset/67445 might have broken GTK Linux 32-bit Debug 64625 2010-08-17 13:49:52 -0700 2010-08-17 13:57:11 -0700 Patch to allow pixel readback from GPU for thumbnail generation. wk44127.patch text/plain 5246 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YWQzZWE5MC4uNjg1NGIwMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wOC0xNyAgVy4gSmFtZXMgTWFj TGVhbiAgPHdqbWFjbGVhbkBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVGh1bWJuYWlscyBub3QgZ2VuZXJhdGVk IGZvciBHUFUgUmVuZGVyZWQgUGFnZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTQ0MTI3CisKKyAgICAgICAgQWRkZWQgZnVuY3Rpb25zIHRvIGFsbG93 IHJlYWRiYWNrIG9mIEdQVSBidWZmZXIgZm9yIGdlbmVyYXRpbmcgQ2hyb21pdW0gdGh1bWJuYWls cy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OnJl YWRQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVu ZGVyZXJDaHJvbWl1bS5oOgorCiAyMDEwLTA4LTE3ICBEYXJpbiBGaXNoZXIgIDxkYXJpbkBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQg YS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1 bS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5jcHAKaW5kZXggMmY3MGVmYS4uNWY5YjMxZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCisrKyBi L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVt LmNwcApAQCAtNTA2LDYgKzUwNiwzNyBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6ZHJh d0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0JgogICAgIG1f bmVlZHNEaXNwbGF5ID0gZmFsc2U7CiB9CiAKK3ZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpy ZWFkUGl4ZWxzKHNraWE6OlBsYXRmb3JtQ2FudmFzKiBjYW52YXNQdHIpCit7CisgICAgaWYgKCFj YW52YXNQdHIpCisgICAgICAgIHJldHVybiA7CisKKyAgICBtYWtlQ29udGV4dEN1cnJlbnQoKTsK KworICAgIGNoZWNrR0xFcnJvcigpOworCisgICAgY29uc3QgU2tCaXRtYXAgYml0bWFwID0gY2Fu dmFzUHRyLT5nZXREZXZpY2UoKS0+YWNjZXNzQml0bWFwKGZhbHNlKTsKKyAgICB2b2lkKiBwaXhl bHMgPSBiaXRtYXAuZ2V0UGl4ZWxzKCk7CisKKyAgICBnbFJlYWRQaXhlbHMoMCwgMCwgYml0bWFw LndpZHRoKCksIGJpdG1hcC5oZWlnaHQoKSwKKyAgICAgICAgICAgICAgICAgR0xfUkdCQSwgR0xf VU5TSUdORURfQllURSwgcGl4ZWxzKTsKKworICAgIGNoZWNrR0xFcnJvcigpOworCisgICAgLy8g RmxpcCBwaXhlbHMgdmVydGljYWxseSAuLi4KKyAgICBPd25QdHI8dW5zaWduZWQgY2hhcj4gbGlu ZVRlbXAobmV3IHVuc2lnbmVkIGNoYXJbYml0bWFwLnJvd0J5dGVzKCldKTsKKyAgICBmb3IgKGlu dCByb3cxID0gMCwgcm93MiA9IGJpdG1hcC5oZWlnaHQoKSAtIDE7IHJvdzEgPCBiaXRtYXAuaGVp Z2h0KCkvMjsgKytyb3cxLCAtLXJvdzIpCisgICAgeworICAgICAgICB1bnNpZ25lZCBjaGFyICpw dHIxID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhciAqPihwaXhlbHMpICsgcm93MSAqIGJpdG1h cC5yb3dCeXRlcygpOworICAgICAgICB1bnNpZ25lZCBjaGFyICpwdHIyID0gc3RhdGljX2Nhc3Q8 dW5zaWduZWQgY2hhciAqPihwaXhlbHMpICsgcm93MiAqIGJpdG1hcC5yb3dCeXRlcygpOworCisg ICAgICAgIG1lbWNweShsaW5lVGVtcC5nZXQoKSwgcHRyMSwgYml0bWFwLnJvd0J5dGVzKCkpOwor ICAgICAgICBtZW1jcHkocHRyMSwgcHRyMiwgYml0bWFwLnJvd0J5dGVzKCkpOworICAgICAgICBt ZW1jcHkocHRyMiwgbGluZVRlbXAuZ2V0KCksIGJpdG1hcC5yb3dCeXRlcygpKTsKKyAgICB9Cit9 CisKKwogLy8gUmV0dXJucyB0aGUgaWQgb2YgdGhlIHRleHR1cmUgY3VycmVudGx5IGFzc29jaWF0 ZWQgd2l0aCB0aGUgbGF5ZXIgb3IKIC8vIC0xIGlmIHRoZSBpZCBoYXNuJ3QgYmVlbiByZWdpc3Rl cmVkIHlldC4KIGludCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmdldFRleHR1cmVJZChMYXllckNo cm9taXVtKiBsYXllcikKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmggYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCmluZGV4IGU0NDc0YjUuLjBhMjBjYTMg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5k ZXJlckNocm9taXVtLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXllclJlbmRlcmVyQ2hyb21pdW0uaApAQCAtODcsNiArODcsOCBAQCBwdWJsaWM6CiAKICAgICBH cmFwaGljc0NvbnRleHQqIHJvb3RMYXllckdyYXBoaWNzQ29udGV4dCgpIGNvbnN0IHsgcmV0dXJu IG1fcm9vdExheWVyR3JhcGhpY3NDb250ZXh0LmdldCgpOyB9CiAKKyAgICB2b2lkIHJlYWRQaXhl bHMoc2tpYTo6UGxhdGZvcm1DYW52YXMqIGNhbnZhc1B0cik7CisKIHByaXZhdGU6CiAgICAgZW51 bSBTaGFkZXJQcm9ncmFtVHlwZSB7IERlYnVnQm9yZGVyUHJvZ3JhbSwgU2Nyb2xsTGF5ZXJQcm9n cmFtLCBDb250ZW50TGF5ZXJQcm9ncmFtLCBDYW52YXNMYXllclByb2dyYW0sIE51bVNoYWRlclBy b2dyYW1UeXBlcyB9OwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCBjNWIyYTVkLi5jOGM5MTliIDEwMDY0NAot LS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxOCBAQAorMjAxMC0wOC0xNyAgVy4gSmFtZXMgTWFjTGVhbiAgPHdq bWFjbGVhbkBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIFtjaHJvbWl1bV0gVGh1bWJuYWlscyBub3QgZ2VuZXJhdGVkIGZvciBHUFUg UmVuZGVyZWQgUGFnZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTQ0MTI3CisKKyAgICAgICAgQWRkZWQgZnVuY3Rpb25zIHRvIGFsbG93IHJlYWRiYWNr IG9mIEdQVSBidWZmZXIgZm9yIGdlbmVyYXRpbmcgQ2hyb21pdW0gdGh1bWJuYWlscy4KKworICAg ICAgICAqIHB1YmxpYy9XZWJWaWV3Lmg6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6OnJlYWRQ aXhlbHMpOgorICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6 OldlYlZpZXdJbXBsOjpyZWFkUGl4ZWxzKToKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuaDoK KwogMjAxMC0wOC0xNyAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+ CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjY1NTE2LgpkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJWaWV3LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGlj L1dlYlZpZXcuaAppbmRleCAxYjk0ZGEyLi4zNDMzMzM1IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hy b21pdW0vcHVibGljL1dlYlZpZXcuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlZp ZXcuaApAQCAtMjEyLDYgKzIxMiw4IEBAIHB1YmxpYzoKICAgICAvLyAoYWNjZXB0IGZhbHNlKSBl ZmZlY3QuICBSZXR1cm4gdHJ1ZSBvbiBzdWNjZXNzLgogICAgIHZpcnR1YWwgYm9vbCBzZXREcm9w RWZmZWN0KGJvb2wgYWNjZXB0KSA9IDA7CiAKKyAgICB2aXJ0dWFsIHZvaWQgcmVhZFBpeGVscyhX ZWJDYW52YXMgKmNhbnZhcykge30KKwogCiAgICAgLy8gU3VwcG9ydCBmb3IgcmVzb3VyY2UgbG9h ZGluZyBpbml0aWF0ZWQgYnkgcGx1Z2lucyAtLS0tLS0tLS0tLS0tLS0tLS0tCiAKZGlmZiAtLWdp dCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJWaWV3SW1wbC5jcHAKaW5kZXggNjJiMjBkNS4uZmYwMGM5YSAxMDA2NDQKLS0tIGEv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTk0Myw2ICs5NDMsMTIgQEAgdm9pZCBXZWJWaWV3SW1w bDo6bGF5b3V0KCkKICAgICB9CiB9CiAKK3ZvaWQgV2ViVmlld0ltcGw6OnJlYWRQaXhlbHMoV2Vi Q2FudmFzICpjYW52YXMpCit7CisgICAgQVNTRVJUKGlzQWNjZWxlcmF0ZWRDb21wb3NpdGluZ0Fj dGl2ZSgpKTsKKyAgICBtX2xheWVyUmVuZGVyZXItPnJlYWRQaXhlbHMoY2FudmFzKTsKK30KKwog dm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdlYlJlY3Qm IHJlY3QpCiB7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwu aCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAppbmRleCBjMjk2MTIxLi45YjA5 MDZjIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKKysrIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBAIC0xNTgsNiArMTU4LDcgQEAgcHVi bGljOgogICAgICAgICBjb25zdCBXZWJQb2ludCYgc2NyZWVuUG9pbnQpOwogICAgIHZpcnR1YWwg aW50IGRyYWdJZGVudGl0eSgpOwogICAgIHZpcnR1YWwgYm9vbCBzZXREcm9wRWZmZWN0KGJvb2wg YWNjZXB0KTsKKyAgICB2aXJ0dWFsIHZvaWQgcmVhZFBpeGVscyhXZWJDYW52YXMgKmNhbnZhcyk7 CiAgICAgdmlydHVhbCB1bnNpZ25lZCBsb25nIGNyZWF0ZVVuaXF1ZUlkZW50aWZpZXJGb3JSZXF1 ZXN0KCk7CiAgICAgdmlydHVhbCB2b2lkIGluc3BlY3RFbGVtZW50QXQoY29uc3QgV2ViUG9pbnQm IHBvaW50KTsKICAgICB2aXJ0dWFsIFdlYlN0cmluZyBpbnNwZWN0b3JTZXR0aW5ncygpIGNvbnN0 Owo= 64628 2010-08-17 13:57:11 -0700 2010-08-19 11:21:10 -0700 Patch to allow pixel readback from GPU for thumbnail generation. wk44127.patch text/plain 5241 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YWQzZWE5MC4uNjg1NGIwMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wOC0xNyAgVy4gSmFtZXMgTWFj TGVhbiAgPHdqbWFjbGVhbkBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVGh1bWJuYWlscyBub3QgZ2VuZXJhdGVk IGZvciBHUFUgUmVuZGVyZWQgUGFnZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTQ0MTI3CisKKyAgICAgICAgQWRkZWQgZnVuY3Rpb25zIHRvIGFsbG93 IHJlYWRiYWNrIG9mIEdQVSBidWZmZXIgZm9yIGdlbmVyYXRpbmcgQ2hyb21pdW0gdGh1bWJuYWls cy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OnJl YWRQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVu ZGVyZXJDaHJvbWl1bS5oOgorCiAyMDEwLTA4LTE3ICBEYXJpbiBGaXNoZXIgIDxkYXJpbkBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQg YS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1 bS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5jcHAKaW5kZXggMmY3MGVmYS4uYjczYWU4NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCisrKyBi L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVt LmNwcApAQCAtNTA2LDYgKzUwNiwzNiBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6ZHJh d0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0JgogICAgIG1f bmVlZHNEaXNwbGF5ID0gZmFsc2U7CiB9CiAKK3ZvaWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpy ZWFkUGl4ZWxzKHNraWE6OlBsYXRmb3JtQ2FudmFzKiBjYW52YXNQdHIpCit7CisgICAgaWYgKCFj YW52YXNQdHIpCisgICAgICAgIHJldHVybjsKKworICAgIG1ha2VDb250ZXh0Q3VycmVudCgpOwor CisgICAgY2hlY2tHTEVycm9yKCk7CisKKyAgICBjb25zdCBTa0JpdG1hcCBiaXRtYXAgPSBjYW52 YXNQdHItPmdldERldmljZSgpLT5hY2Nlc3NCaXRtYXAoZmFsc2UpOworICAgIHZvaWQqIHBpeGVs cyA9IGJpdG1hcC5nZXRQaXhlbHMoKTsKKworICAgIGdsUmVhZFBpeGVscygwLCAwLCBiaXRtYXAu d2lkdGgoKSwgYml0bWFwLmhlaWdodCgpLAorICAgICAgICAgICAgICAgICBHTF9SR0JBLCBHTF9V TlNJR05FRF9CWVRFLCBwaXhlbHMpOworCisgICAgY2hlY2tHTEVycm9yKCk7CisKKyAgICAvLyBG bGlwIHBpeGVscyB2ZXJ0aWNhbGx5IC4uLgorICAgIE93blB0cjx1bnNpZ25lZCBjaGFyPiBsaW5l VGVtcChuZXcgdW5zaWduZWQgY2hhcltiaXRtYXAucm93Qnl0ZXMoKV0pOworICAgIGZvciAoaW50 IHJvdzEgPSAwLCByb3cyID0gYml0bWFwLmhlaWdodCgpIC0gMTsgcm93MSA8IGJpdG1hcC5oZWln aHQoKSAvIDI7ICsrcm93MSwgLS1yb3cyKXsKKyAgICAgICAgdW5zaWduZWQgY2hhciAqcHRyMSA9 IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXIgKj4ocGl4ZWxzKSArIHJvdzEgKiBiaXRtYXAucm93 Qnl0ZXMoKTsKKyAgICAgICAgdW5zaWduZWQgY2hhciAqcHRyMiA9IHN0YXRpY19jYXN0PHVuc2ln bmVkIGNoYXIgKj4ocGl4ZWxzKSArIHJvdzIgKiBiaXRtYXAucm93Qnl0ZXMoKTsKKworICAgICAg ICBtZW1jcHkobGluZVRlbXAuZ2V0KCksIHB0cjEsIGJpdG1hcC5yb3dCeXRlcygpKTsKKyAgICAg ICAgbWVtY3B5KHB0cjEsIHB0cjIsIGJpdG1hcC5yb3dCeXRlcygpKTsKKyAgICAgICAgbWVtY3B5 KHB0cjIsIGxpbmVUZW1wLmdldCgpLCBiaXRtYXAucm93Qnl0ZXMoKSk7CisgICAgfQorfQorCisK IC8vIFJldHVybnMgdGhlIGlkIG9mIHRoZSB0ZXh0dXJlIGN1cnJlbnRseSBhc3NvY2lhdGVkIHdp dGggdGhlIGxheWVyIG9yCiAvLyAtMSBpZiB0aGUgaWQgaGFzbid0IGJlZW4gcmVnaXN0ZXJlZCB5 ZXQuCiBpbnQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpnZXRUZXh0dXJlSWQoTGF5ZXJDaHJvbWl1 bSogbGF5ZXIpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAppbmRleCBlNDQ3NGI1Li4wYTIwY2EzIDEwMDY0 NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJS ZW5kZXJlckNocm9taXVtLmgKQEAgLTg3LDYgKzg3LDggQEAgcHVibGljOgogCiAgICAgR3JhcGhp Y3NDb250ZXh0KiByb290TGF5ZXJHcmFwaGljc0NvbnRleHQoKSBjb25zdCB7IHJldHVybiBtX3Jv b3RMYXllckdyYXBoaWNzQ29udGV4dC5nZXQoKTsgfQogCisgICAgdm9pZCByZWFkUGl4ZWxzKHNr aWE6OlBsYXRmb3JtQ2FudmFzKiBjYW52YXNQdHIpOworCiBwcml2YXRlOgogICAgIGVudW0gU2hh ZGVyUHJvZ3JhbVR5cGUgeyBEZWJ1Z0JvcmRlclByb2dyYW0sIFNjcm9sbExheWVyUHJvZ3JhbSwg Q29udGVudExheWVyUHJvZ3JhbSwgQ2FudmFzTGF5ZXJQcm9ncmFtLCBOdW1TaGFkZXJQcm9ncmFt VHlwZXMgfTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dlYktp dC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggYzViMmE1ZC4uYzhjOTE5YiAxMDA2NDQKLS0tIGEv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMTggQEAKKzIwMTAtMDgtMTcgIFcuIEphbWVzIE1hY0xlYW4gIDx3am1hY2xl YW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBbY2hyb21pdW1dIFRodW1ibmFpbHMgbm90IGdlbmVyYXRlZCBmb3IgR1BVIFJlbmRl cmVkIFBhZ2VzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD00NDEyNworCisgICAgICAgIEFkZGVkIGZ1bmN0aW9ucyB0byBhbGxvdyByZWFkYmFjayBvZiBH UFUgYnVmZmVyIGZvciBnZW5lcmF0aW5nIENocm9taXVtIHRodW1ibmFpbHMuCisKKyAgICAgICAg KiBwdWJsaWMvV2ViVmlldy5oOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3OjpyZWFkUGl4ZWxz KToKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJW aWV3SW1wbDo6cmVhZFBpeGVscyk6CisgICAgICAgICogc3JjL1dlYlZpZXdJbXBsLmg6CisKIDIw MTAtMDgtMTcgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmlldy5ib3RAZ21haWwuY29tPgogCiAg ICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI2NTUxNi4KZGlmZiAtLWdpdCBhL1dlYktp dC9jaHJvbWl1bS9wdWJsaWMvV2ViVmlldy5oIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJW aWV3LmgKaW5kZXggMWI5NGRhMi4uMzQzMzMzNSAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJWaWV3LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJWaWV3LmgK QEAgLTIxMiw2ICsyMTIsOCBAQCBwdWJsaWM6CiAgICAgLy8gKGFjY2VwdCBmYWxzZSkgZWZmZWN0 LiAgUmV0dXJuIHRydWUgb24gc3VjY2Vzcy4KICAgICB2aXJ0dWFsIGJvb2wgc2V0RHJvcEVmZmVj dChib29sIGFjY2VwdCkgPSAwOwogCisgICAgdmlydHVhbCB2b2lkIHJlYWRQaXhlbHMoV2ViQ2Fu dmFzICpjYW52YXMpIHt9CisKIAogICAgIC8vIFN1cHBvcnQgZm9yIHJlc291cmNlIGxvYWRpbmcg aW5pdGlhdGVkIGJ5IHBsdWdpbnMgLS0tLS0tLS0tLS0tLS0tLS0tLQogCmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViVmlld0ltcGwuY3BwCmluZGV4IDYyYjIwZDUuLmZmMDBjOWEgMTAwNjQ0Ci0tLSBhL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViVmlld0ltcGwuY3BwCkBAIC05NDMsNiArOTQzLDEyIEBAIHZvaWQgV2ViVmlld0ltcGw6Omxh eW91dCgpCiAgICAgfQogfQogCit2b2lkIFdlYlZpZXdJbXBsOjpyZWFkUGl4ZWxzKFdlYkNhbnZh cyAqY2FudmFzKQoreworICAgIEFTU0VSVChpc0FjY2VsZXJhdGVkQ29tcG9zaXRpbmdBY3RpdmUo KSk7CisgICAgbV9sYXllclJlbmRlcmVyLT5yZWFkUGl4ZWxzKGNhbnZhcyk7Cit9CisKIHZvaWQg V2ViVmlld0ltcGw6OnBhaW50KFdlYkNhbnZhcyogY2FudmFzLCBjb25zdCBXZWJSZWN0JiByZWN0 KQogewogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmggYi9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKaW5kZXggYzI5NjEyMS4uOWIwOTA2YyAx MDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCisrKyBiL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaApAQCAtMTU4LDYgKzE1OCw3IEBAIHB1YmxpYzoK ICAgICAgICAgY29uc3QgV2ViUG9pbnQmIHNjcmVlblBvaW50KTsKICAgICB2aXJ0dWFsIGludCBk cmFnSWRlbnRpdHkoKTsKICAgICB2aXJ0dWFsIGJvb2wgc2V0RHJvcEVmZmVjdChib29sIGFjY2Vw dCk7CisgICAgdmlydHVhbCB2b2lkIHJlYWRQaXhlbHMoV2ViQ2FudmFzICpjYW52YXMpOwogICAg IHZpcnR1YWwgdW5zaWduZWQgbG9uZyBjcmVhdGVVbmlxdWVJZGVudGlmaWVyRm9yUmVxdWVzdCgp OwogICAgIHZpcnR1YWwgdm9pZCBpbnNwZWN0RWxlbWVudEF0KGNvbnN0IFdlYlBvaW50JiBwb2lu dCk7CiAgICAgdmlydHVhbCBXZWJTdHJpbmcgaW5zcGVjdG9yU2V0dGluZ3MoKSBjb25zdDsK 64877 2010-08-19 11:21:14 -0700 2010-08-25 13:16:28 -0700 Patch bug-44127-20100819142058.patch text/plain 5609 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YWQzZWE5MGZhOTdjNzA2ZWQ0Y2UwZWEzODVkMmM5Mzk5OGQ5MjVjYy4uMGFkMWVlNTUzMGVlZDEx NDFjYjU0ZjRmZTYxYWEwM2EwNTlhOWM1MCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wOC0xOSAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKworICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxz KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hy b21pdW0uaDoKKwogMjAxMC0wOC0xNyAgRGFyaW4gRmlzaGVyICA8ZGFyaW5AY2hyb21pdW0ub3Jn PgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwIGIv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0u Y3BwCmluZGV4IDJmNzBlZmFkMDI2MDZiNmEzN2ExMjE4ZjkzYjZkY2I3M2UxZGU3OTYuLjA0YjY5 ZTExZGMzMWRiZjY3ODZkYzA1NjliMmYzYTVlOWFkZTYxMDYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcAorKysg Yi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1 bS5jcHAKQEAgLTUwNiw2ICs1MDYsMzMgQEAgdm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmRy YXdMYXllcnMoY29uc3QgSW50UmVjdCYgdXBkYXRlUmVjdCwgY29uc3QgSW50UmVjdCYKICAgICBt X25lZWRzRGlzcGxheSA9IGZhbHNlOwogfQogCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6 Z2V0RnJhbWVidWZmZXJQaXhlbHModm9pZCAqcGl4ZWxzLCBjb25zdCBpbnQgd2lkdGgsIGNvbnN0 IGludCBoZWlnaHQsIGNvbnN0IGludCByb3dCeXRlcykKK3sKKyAgICBpZiAoIXBpeGVscykKKyAg ICAgICAgcmV0dXJuOworCisgICAgbWFrZUNvbnRleHRDdXJyZW50KCk7CisKKyAgICBjaGVja0dM RXJyb3IoKTsKKworICAgIGdsUmVhZFBpeGVscygwLCAwLCB3aWR0aCwgaGVpZ2h0LAorICAgICAg ICAgICAgICAgICBHTF9SR0JBLCBHTF9VTlNJR05FRF9CWVRFLCBwaXhlbHMpOworCisgICAgY2hl Y2tHTEVycm9yKCk7CisKKyAgICAvLyBGbGlwIHBpeGVscyB2ZXJ0aWNhbGx5LgorICAgIE93blB0 cjx1bnNpZ25lZCBjaGFyPiBsaW5lVGVtcChuZXcgdW5zaWduZWQgY2hhcltyb3dCeXRlc10pOwor ICAgIGZvciAoaW50IHJvdzEgPSAwLCByb3cyID0gaGVpZ2h0IC0gMTsgcm93MSA8IGhlaWdodCAv IDI7ICsrcm93MSwgLS1yb3cyKSB7CisKKyAgICAgICAgdW5zaWduZWQgY2hhciogcHRyMSA9IHN0 YXRpY19jYXN0PHVuc2lnbmVkIGNoYXIqPihwaXhlbHMpICsgcm93MSAqIHJvd0J5dGVzOworICAg ICAgICB1bnNpZ25lZCBjaGFyKiBwdHIyID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcio+KHBp eGVscykgKyByb3cyICogcm93Qnl0ZXM7CisKKyAgICAgICAgbWVtY3B5KGxpbmVUZW1wLmdldCgp LCBwdHIxLCByb3dCeXRlcyk7CisgICAgICAgIG1lbWNweShwdHIxLCBwdHIyLCByb3dCeXRlcyk7 CisgICAgICAgIG1lbWNweShwdHIyLCBsaW5lVGVtcC5nZXQoKSwgcm93Qnl0ZXMpOworICAgIH0K K30KKwogLy8gUmV0dXJucyB0aGUgaWQgb2YgdGhlIHRleHR1cmUgY3VycmVudGx5IGFzc29jaWF0 ZWQgd2l0aCB0aGUgbGF5ZXIgb3IKIC8vIC0xIGlmIHRoZSBpZCBoYXNuJ3QgYmVlbiByZWdpc3Rl cmVkIHlldC4KIGludCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmdldFRleHR1cmVJZChMYXllckNo cm9taXVtKiBsYXllcikKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmggYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCmluZGV4IGU0NDc0YjVhMDI1MWQ1M2Ew NzNkNGI3NTkwYTA1N2Q5ZjkxYjY2MzkuLmFlOWY1NWNiM2U2MzQyMTFkNjJjMzBmMDEwM2IzMDAy NzhiODc4MmIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v TGF5ZXJSZW5kZXJlckNocm9taXVtLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaApAQCAtODcsNiArODcsOCBAQCBwdWJsaWM6 CiAKICAgICBHcmFwaGljc0NvbnRleHQqIHJvb3RMYXllckdyYXBoaWNzQ29udGV4dCgpIGNvbnN0 IHsgcmV0dXJuIG1fcm9vdExheWVyR3JhcGhpY3NDb250ZXh0LmdldCgpOyB9CiAKKyAgICB2b2lk IGdldEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgaW50IHdpZHRoLCBjb25z dCBpbnQgaGVpZ2h0LCBjb25zdCBpbnQgcm93Qnl0ZXMpOworCiBwcml2YXRlOgogICAgIGVudW0g U2hhZGVyUHJvZ3JhbVR5cGUgeyBEZWJ1Z0JvcmRlclByb2dyYW0sIFNjcm9sbExheWVyUHJvZ3Jh bSwgQ29udGVudExheWVyUHJvZ3JhbSwgQ2FudmFzTGF5ZXJQcm9ncmFtLCBOdW1TaGFkZXJQcm9n cmFtVHlwZXMgfTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggYzViMmE1ZDQ2N2EzNzhkNzRhMDZiZDIwMjFj MGIyZjRjOWM3NDE3My4uNmMxMGYwNzQzOTQ1ODU0M2M2ZDVkNGJhN2JmZjE4MWQ1OTk3Y2RjNyAx MDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTAtMDgtMTkgIFcuIEphbWVzIE1hY0xl YW4gIDx3am1hY2xlYW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBbY2hyb21pdW1dIFRodW1ibmFpbHMgbm90IGdlbmVyYXRlZCBm b3IgR1BVIFJlbmRlcmVkIFBhZ2VzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD00NDEyNworCisgICAgICAgIE1vZGlmaWVkIFdlYlZpZXdJbXBsOjpwYWlu dCgpIHRvIGRldGVjdCBub24tbnVsbCBjYW52YXMgcG9pbnRlcnMgd2hlbgorICAgICAgICBhY2Nl bGVyYXRlZCBjb21wb3NpdGluZyBpcyBhY3RpdmUsIGFuZCBpbnN0ZWFkIGZpbGxzIHRoZSBwaXhl bCBidWZmZXIKKyAgICAgICAgZnJvbSB0aGUgR1BVIGZyYW1lYnVmZmVyLgorCisgICAgICAgICog c3JjL1dlYlZpZXdJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6OnBhaW50 KToKKwogMjAxMC0wOC0xNyAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5j b20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjY1NTE2LgpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAgYi9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYlZpZXdJbXBsLmNwcAppbmRleCA2MmIyMGQ1ZmI1OTQ3N2RmMjQ0OGIwM2JhOTVlODgz MDUxYTE5YjFkLi41ZDg2MjQ3MmFmYmI4NmU5MmFmZjNiMzNhYTkyMjg0ZGU0YmEzMWMwIDEwMDY0 NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcAorKysgYi9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcApAQCAtMTE0LDYgKzExNCwxMCBAQAogI2luY2x1 ZGUgIldlYlZpZXdDbGllbnQuaCIKICNpbmNsdWRlICJ3dGYvT3duUHRyLmgiCiAKKyNpZiBXRUJL SVRfVVNJTkdfQ0cKKyNpbmNsdWRlIDxDb3JlR3JhcGhpY3MvQ0dDb250ZXh0Lmg+CisjZW5kaWYK KwogI2lmIE9TKFdJTkRPV1MpCiAjaW5jbHVkZSAiUmVuZGVyVGhlbWVDaHJvbWl1bVdpbi5oIgog I2Vsc2UKQEAgLTk1NCw2ICs5NTgsMzUgQEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2Fu dmFzKiBjYW52YXMsIGNvbnN0IFdlYlJlY3QmIHJlY3QpCiAgICAgICAgICAgICB3ZWJmcmFtZS0+ cGFpbnQoY2FudmFzLCByZWN0KTsKICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCiAg ICAgfSBlbHNlIHsKKyAgICAgICAgLy8gSWYgY2FudmFzIGlzIG5vbi1OVUxMLCB3ZSBqdXN0IHJl YWQgdGhlIHBpeGVscyBmcm9tCisgICAgICAgIC8vIHRoZSBHUFUgZnJhbWVidWZmZXIuCisgICAg ICAgIGlmIChjYW52YXMpIHsKKyNpZiBXRUJLSVRfVVNJTkdfU0tJQQorICAgICAgICAgICAgY29u c3QgU2tCaXRtYXAgYml0bWFwID0gY2FudmFzLT5nZXREZXZpY2UoKS0+YWNjZXNzQml0bWFwKGZh bHNlKTsKKworICAgICAgICAgICAgaW50IHdpZHRoID0gYml0bWFwLndpZHRoKCk7CisgICAgICAg ICAgICBpbnQgaGVpZ2h0ID0gYml0bWFwLmhlaWdodCgpOworICAgICAgICAgICAgaW50IHJvd0J5 dGVzID0gYml0bWFwLnJvd0J5dGVzKCk7CisKKyAgICAgICAgICAgIFNrQXV0b0xvY2tQaXhlbHMg Yml0bWFwTG9jayhiaXRtYXApOworICAgICAgICAgICAgdm9pZCogcGl4ZWxzID0gYml0bWFwLmdl dFBpeGVscygpOworI2VsaWYgV0VCS0lUX1VTSU5HX0NHCisgICAgICAgICAgICBDR0NvbnRleHRS ZWYgYml0bWFwID0gcmVpbnRlcnByZXRfY2FzdDxDR0NvbnRleHRSZWY+KGNhbnZhcyk7CisKKyAg ICAgICAgICAgIGludCB3aWR0aCA9IENHQml0bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcCk7Cisg ICAgICAgICAgICBpbnQgaGVpZ2h0ID0gQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1hcCk7 CisgICAgICAgICAgICBpbnQgcm93Qnl0ZXMgPSBDR0JpdG1hcENvbnRleHRHZXRCeXRlc1BlclJv dyhiaXRtYXApOworCisgICAgICAgICAgICB2b2lkKiBwaXhlbHMgPSBDR0JpdG1hcENvbnRleHRH ZXREYXRhKGJpdG1hcCk7CisgICAgICAgICAgICBBU1NFUlQocGl4ZWxzKTsKKyNlbHNlCisjZXJy b3IgTXVzdCBwb3J0IHRvIHlvdXIgcGxhdGZvcm0uCisjZW5kaWYKKworICAgICAgICAgICAgbV9s YXllclJlbmRlcmVyLT5nZXRGcmFtZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHdpZHRoLCBoZWlnaHQs IHJvd0J5dGVzKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCiAgICAgICAgIC8v IERyYXcgdGhlIGNvbnRlbnRzIG9mIHRoZSByb290IGxheWVyLgogICAgICAgICB1cGRhdGVSb290 TGF5ZXJDb250ZW50cyhyZWN0KTsKIAo= 65465 2010-08-25 13:16:33 -0700 2010-08-30 08:54:32 -0700 Patch bug-44127-20100825161610.patch text/plain 10013 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZWI1OTEwZWRhOWE0MGJmOTkwNDQ2Yzc0MWQzZDFhMjViMTYyMWFlNy4uNTg0NDc5NTJkNWE5MjY4 NWVlNWZmOTg5MzYxYTc5ZTZiM2NlZGJkMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wOC0yNSAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKworICAgICAgICBBZGRz IHBpeGVsLXJlYWRiYWNrIGZvciBHUFUgY29tcG9zaXRlZCBwYWdlcyB0byBhbGxvdyBmb3IgdGh1 bWJuYWlsaW5nLAorICAgICAgICBwcmludGluZyBhbmQgb3RoZXIgc2VydmljZXMgdG8gd29yayB3 aXRoIEdQVSByZW5kZXJlZCBwYWdlcy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXll clJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpwcmVzZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVy ZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29y ZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpnZXRSb290TGF5ZXJUZXh0dXJlV2lkdGgpOgorICAg ICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpnZXRSb290TGF5ZXJUZXh0dXJl SGVpZ2h0KToKKwogMjAxMC0wOC0yNSAgSWx5YSBUaWtob25vdnNreSAgPGxvaXNsb0BjaHJvbWl1 bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWXVyeSBTZW1pa2hhdHNreS4KZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9t aXVtLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmNwcAppbmRleCBjZjIzODcxOGIyMWJiNDBiYjY5NzY2MjdkOWYyMzM4NTRlNDQ2 OWZiLi5iYWNjODUyYjBkYjFjZGMzZThmYTJlMjdlNzIyYThjZDVmNGRhZjMyIDEwMDY0NAotLS0g YS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1 bS5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uY3BwCkBAIC0zMTAsMTEgKzMxMCw0MSBAQCB2b2lkIExheWVyUmVuZGVyZXJD aHJvbWl1bTo6ZHJhd0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRS ZWN0JgogCiAgICAgR0xDKGdsRGlzYWJsZShHTF9TQ0lTU09SX1RFU1QpKTsKIAorICAgIGdsRmx1 c2goKTsKK30KKwordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnByZXNlbnQoKQorewogICAg IG1fZ2xlczJDb250ZXh0LT5zd2FwQnVmZmVycygpOwogCiAgICAgbV9uZWVkc0Rpc3BsYXkgPSBm YWxzZTsKIH0KIAordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4 ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgaW50IHdpZHRoLCBjb25zdCBpbnQgaGVpZ2h0LCBjb25z dCBpbnQgcm93Qnl0ZXMpCit7CisgICAgQVNTRVJUKHdpZHRoID09IG1fcm9vdExheWVyVGV4dHVy ZVdpZHRoICYmIGhlaWdodCA9PSBtX3Jvb3RMYXllclRleHR1cmVIZWlnaHQpOworCisgICAgaWYg KCFwaXhlbHMpCisgICAgICAgIHJldHVybjsKKworICAgIG1ha2VDb250ZXh0Q3VycmVudCgpOwor CisgICAgR0xDKGdsUmVhZFBpeGVscygwLCAwLCB3aWR0aCwgaGVpZ2h0LAorICAgICAgICAgICAg ICAgICAgICAgR0xfUkdCQSwgR0xfVU5TSUdORURfQllURSwgcGl4ZWxzKSk7CisKKyAgICAvLyBG bGlwIHBpeGVscyB2ZXJ0aWNhbGx5LgorICAgIE93blB0cjx1bnNpZ25lZCBjaGFyPiBsaW5lVGVt cChuZXcgdW5zaWduZWQgY2hhcltyb3dCeXRlc10pOworICAgIGZvciAoaW50IHJvdzEgPSAwLCBy b3cyID0gaGVpZ2h0IC0gMTsgcm93MSA8IGhlaWdodCAvIDI7ICsrcm93MSwgLS1yb3cyKSB7CisK KyAgICAgICAgdW5zaWduZWQgY2hhciogcHRyMSA9IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXIq PihwaXhlbHMpICsgcm93MSAqIHJvd0J5dGVzOworICAgICAgICB1bnNpZ25lZCBjaGFyKiBwdHIy ID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcio+KHBpeGVscykgKyByb3cyICogcm93Qnl0ZXM7 CisKKyAgICAgICAgbWVtY3B5KGxpbmVUZW1wLmdldCgpLCBwdHIxLCByb3dCeXRlcyk7CisgICAg ICAgIG1lbWNweShwdHIxLCBwdHIyLCByb3dCeXRlcyk7CisgICAgICAgIG1lbWNweShwdHIyLCBs aW5lVGVtcC5nZXQoKSwgcm93Qnl0ZXMpOworICAgIH0KK30KKwogLy8gRklYTUU6IFRoaXMgbWV0 aG9kIHNob3VsZCBldmVudHVhbGx5IGJlIHJlcGxhY2VkIGJ5IGEgcHJvcGVyIHRleHR1cmUgbWFu YWdlci4KIHVuc2lnbmVkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6Y3JlYXRlTGF5ZXJUZXh0dXJl KCkKIHsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5 ZXJSZW5kZXJlckNocm9taXVtLmggYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCmluZGV4IDI0YmJlNjUyODI4YzFmOThhNTMxZTIxMjhm NjkxOGQxZTllOGMzNjMuLmI1YzkzODcxYjA5Zjc1NTdmMDE1ZjJmNzU1ZTg2ZTExZDU4NTUwNWIg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5k ZXJlckNocm9taXVtLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXllclJlbmRlcmVyQ2hyb21pdW0uaApAQCAtNjQsNiArNjQsNyBAQCBwdWJsaWM6CiAgICAgLy8g VXBkYXRlcyB0aGUgY29udGVudHMgb2YgdGhlIHJvb3QgbGF5ZXIgdGhhdCBmYWxsIGluc2lkZSB0 aGUgdXBkYXRlUmVjdCBhbmQgcmVjb21wb3NpdGVzCiAgICAgLy8gYWxsIHRoZSBsYXllcnMuCiAg ICAgdm9pZCBkcmF3TGF5ZXJzKGNvbnN0IEludFJlY3QmIHVwZGF0ZVJlY3QsIGNvbnN0IEludFJl Y3QmIHZpc2libGVSZWN0LCBjb25zdCBJbnRSZWN0JiBjb250ZW50UmVjdCwgY29uc3QgSW50UG9p bnQmIHNjcm9sbFBvc2l0aW9uKTsKKyAgICB2b2lkIHByZXNlbnQoKTsgLy8gUGVyZm9ybSBidWZm ZXIgc3dhcCB0byBwcmVzZW50IHJlbmRlcmVkIGJ1ZmZlci4KIAogICAgIHZvaWQgc2V0Um9vdExh eWVyKFBhc3NSZWZQdHI8TGF5ZXJDaHJvbWl1bT4gbGF5ZXIpIHsgbV9yb290TGF5ZXIgPSBsYXll cjsgfQogICAgIExheWVyQ2hyb21pdW0qIHJvb3RMYXllcigpIHsgcmV0dXJuIG1fcm9vdExheWVy LmdldCgpOyB9CkBAIC05MCw2ICs5MSwxMCBAQCBwdWJsaWM6CiAgICAgY29uc3QgQ29udGVudExh eWVyQ2hyb21pdW06OlNoYXJlZFZhbHVlcyogY29udGVudExheWVyU2hhcmVkVmFsdWVzKCkgY29u c3QgeyByZXR1cm4gbV9jb250ZW50TGF5ZXJTaGFyZWRWYWx1ZXMuZ2V0KCk7IH0KICAgICBjb25z dCBDYW52YXNMYXllckNocm9taXVtOjpTaGFyZWRWYWx1ZXMqIGNhbnZhc0xheWVyU2hhcmVkVmFs dWVzKCkgY29uc3QgeyByZXR1cm4gbV9jYW52YXNMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsgfQog CisgICAgaW50IGdldFJvb3RMYXllclRleHR1cmVXaWR0aCgpIGNvbnN0IHsgcmV0dXJuIG1fcm9v dExheWVyVGV4dHVyZVdpZHRoOyB9CisgICAgaW50IGdldFJvb3RMYXllclRleHR1cmVIZWlnaHQo KSBjb25zdCB7IHJldHVybiBtX3Jvb3RMYXllclRleHR1cmVIZWlnaHQ7IH0KKyAgICB2b2lkIGdl dEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgaW50IHdpZHRoLCBjb25zdCBp bnQgaGVpZ2h0LCBjb25zdCBpbnQgcm93Qnl0ZXMpOworCiBwcml2YXRlOgogICAgIHZvaWQgdXBk YXRlTGF5ZXJzUmVjdXJzaXZlKExheWVyQ2hyb21pdW0qIGxheWVyLCBjb25zdCBUcmFuc2Zvcm1h dGlvbk1hdHJpeCYgcGFyZW50TWF0cml4LCBmbG9hdCBvcGFjaXR5KTsKIApkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5k ZXggNWQ4NjBlZDcxNDQxYzQwMTI0NmQ4ZGZjMTc3MjNlNWViZTliZmE0MS4uNmM2OTQyYzE2Y2Ri NTZhNjA3YjFmYjQyNGU5MDA4NjRlOGFhOTJiYyAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTgg QEAKKzIwMTAtMDgtMjUgIFcuIEphbWVzIE1hY0xlYW4gIDx3am1hY2xlYW5AY2hyb21pdW0ub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtjaHJv bWl1bV0gVGh1bWJuYWlscyBub3QgZ2VuZXJhdGVkIGZvciBHUFUgUmVuZGVyZWQgUGFnZXMKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0MTI3CisKKyAg ICAgICAgTW9kaWZpZWQgV2ViVmlld0ltcGw6OnBhaW50KCkgdG8gZGV0ZWN0IG5vbi1udWxsIGNh bnZhcyBwb2ludGVycyB3aGVuCisgICAgICAgIGFjY2VsZXJhdGVkIGNvbXBvc2l0aW5nIGlzIGFj dGl2ZSwgYW5kIGluc3RlYWQgZmlsbHMgdGhlIHBpeGVsIGJ1ZmZlcgorICAgICAgICBmcm9tIHRo ZSBHUFUgZnJhbWVidWZmZXIuIEluY2x1ZGVzIHJlLXNjYWxpbmcgc3VwcG9ydCB3aGVuIHByb3Zp ZGVkCisgICAgICAgIGNhbnZhcyBkb2VzIG5vdCBtYXRjaCBzaXplIG9mIGN1cnJlbnQgcmVuZGVy IGxheWVyLgorCisgICAgICAgICogc3JjL1dlYlZpZXdJbXBsLmNwcDoKKyAgICAgICAgKFdlYktp dDo6V2ViVmlld0ltcGw6OnBhaW50KToKKwogMjAxMC0wOC0yNSAgU2F0aXNoIFNhbXBhdGggIDxz YXRpc2hAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEplcmVteSBPcmxvdy4K ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKaW5kZXggMzgzYjcxNjczMTRlZGFmMzQyZGFl YjQ4ZjNiNTY2MTBlZDc1MzE0OC4uNGJkNTZjMDk5MTAxMDhmYjYyNmMwNjg4NDVjOGFkZDQwMjQ5 Y2Y4NyAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTExNSw2ICsxMTUsMTAg QEAKICNpbmNsdWRlICJXZWJWaWV3Q2xpZW50LmgiCiAjaW5jbHVkZSAid3RmL093blB0ci5oIgog CisjaWYgV0VCS0lUX1VTSU5HX0NHCisjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NHQ29udGV4dC5o PgorI2VuZGlmCisKICNpZiBPUyhXSU5ET1dTKQogI2luY2x1ZGUgIlJlbmRlclRoZW1lQ2hyb21p dW1XaW4uaCIKICNlbHNlCkBAIC05NTUsNiArOTU5LDcgQEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFp bnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdlYlJlY3QmIHJlY3QpCiAgICAgICAgICAgICB3 ZWJmcmFtZS0+cGFpbnQoY2FudmFzLCByZWN0KTsKICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9T SVRJTkcpCiAgICAgfSBlbHNlIHsKKwogICAgICAgICAvLyBEcmF3IHRoZSBjb250ZW50cyBvZiB0 aGUgcm9vdCBsYXllci4KICAgICAgICAgdXBkYXRlUm9vdExheWVyQ29udGVudHMocmVjdCk7CiAK QEAgLTk3MSw2ICs5NzYsNzggQEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBj YW52YXMsIGNvbnN0IFdlYlJlY3QmIHJlY3QpCiAKICAgICAgICAgLy8gQXNrIHRoZSBsYXllciBj b21wb3NpdG9yIHRvIHJlZHJhdyBhbGwgdGhlIGxheWVycy4KICAgICAgICAgbV9sYXllclJlbmRl cmVyLT5kcmF3TGF5ZXJzKHJlY3QsIHZpc2libGVSZWN0LCBjb250ZW50UmVjdCwgSW50UG9pbnQo dmlldy0+c2Nyb2xsWCgpLCB2aWV3LT5zY3JvbGxZKCkpKTsKKworICAgICAgICAvLyBJZiBhIGNh bnZhcyB3YXMgcGFzc2VkIGluLCB3ZSB1c2UgaXQgdG8gZ3JhYiBhIGNvcHkgb2YgdGhlCisgICAg ICAgIC8vIGZyZXNobHktcmVuZGVyZWQgcGl4ZWxzLgorICAgICAgICBpZiAoY2FudmFzKSB7Cisg ICAgICAgICAgICB2b2lkKiBwaXhlbHMgPSAwOworI2lmIFdFQktJVF9VU0lOR19TS0lBCisgICAg ICAgICAgICBjb25zdCBTa0JpdG1hcCBiaXRtYXAgPSBjYW52YXMtPmdldERldmljZSgpLT5hY2Nl c3NCaXRtYXAoZmFsc2UpOworCisgICAgICAgICAgICBpbnQgd2lkdGggPSBiaXRtYXAud2lkdGgo KTsKKyAgICAgICAgICAgIGludCBoZWlnaHQgPSBiaXRtYXAuaGVpZ2h0KCk7CisgICAgICAgICAg ICBpbnQgcm93Qnl0ZXMgPSBiaXRtYXAucm93Qnl0ZXMoKTsKKworICAgICAgICAgICAgU2tBdXRv TG9ja1BpeGVscyBiaXRtYXBMb2NrKGJpdG1hcCk7CisKKyAgICAgICAgICAgIGlmIChtX2xheWVy UmVuZGVyZXItPmdldFJvb3RMYXllclRleHR1cmVXaWR0aCgpID09IHdpZHRoCisgICAgICAgICAg ICAgICAgJiYgbV9sYXllclJlbmRlcmVyLT5nZXRSb290TGF5ZXJUZXh0dXJlSGVpZ2h0KCkgPT0g aGVpZ2h0KSB7CisgICAgICAgICAgICAgICAgcGl4ZWxzID0gYml0bWFwLmdldFBpeGVscygpOwor ICAgICAgICAgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4 ZWxzLCB3aWR0aCwgaGVpZ2h0LCByb3dCeXRlcyk7CisgICAgICAgICAgICB9IGVsc2UgeworICAg ICAgICAgICAgICAgIHdpZHRoID0gbV9sYXllclJlbmRlcmVyLT5nZXRSb290TGF5ZXJUZXh0dXJl V2lkdGgoKTsKKyAgICAgICAgICAgICAgICBoZWlnaHQgPSBtX2xheWVyUmVuZGVyZXItPmdldFJv b3RMYXllclRleHR1cmVIZWlnaHQoKTsKKworICAgICAgICAgICAgICAgIC8vIENyZWF0ZSB0ZW1w IGJpdG1hcCBvZiBjb3JyZWN0IHNpemUgdG8gY29weSBwaXhlbHMgaW50by4KKyAgICAgICAgICAg ICAgICBPd25QdHI8c2tpYTo6UGxhdGZvcm1DYW52YXM+IGNhbnZhczIgPSBPd25QdHI8c2tpYTo6 UGxhdGZvcm1DYW52YXM+KG5ldyBza2lhOjpQbGF0Zm9ybUNhbnZhcygpKTsKKyAgICAgICAgICAg ICAgICBpZiAoY2FudmFzMi5nZXQoKSAmJiBjYW52YXMyLT5pbml0aWFsaXplKHdpZHRoLCBoZWln aHQsIHRydWUpKSB7CisgICAgICAgICAgICAgICAgICAgIFNrQml0bWFwIGJpdG1hcDIgPSBjYW52 YXMyLT5nZXREZXZpY2UoKS0+YWNjZXNzQml0bWFwKGZhbHNlKTsKKyAgICAgICAgICAgICAgICAg ICAgcGl4ZWxzID0gYml0bWFwMi5nZXRQaXhlbHMoKTsKKyAgICAgICAgICAgICAgICAgICAgbV9s YXllclJlbmRlcmVyLT5nZXRGcmFtZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHdpZHRoLCBoZWlnaHQs IHJvd0J5dGVzKTsKKyAgICAgICAgICAgICAgICAgICAgY2FudmFzLT5kcmF3Qml0bWFwKGJpdG1h cDIsIDAsIDAsIDApOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyNlbGlmIFdF QktJVF9VU0lOR19DRworICAgICAgICAgICAgQ0dDb250ZXh0UmVmIGJpdG1hcCA9IHJlaW50ZXJw cmV0X2Nhc3Q8Q0dDb250ZXh0UmVmPihjYW52YXMpOworCisgICAgICAgICAgICBpbnQgd2lkdGgg PSBDR0JpdG1hcENvbnRleHRHZXRXaWR0aChiaXRtYXApOworICAgICAgICAgICAgaW50IGhlaWdo dCA9IENHQml0bWFwQ29udGV4dEdldEhlaWdodChiaXRtYXApOworICAgICAgICAgICAgaW50IHJv d0J5dGVzID0gQ0dCaXRtYXBDb250ZXh0R2V0Qnl0ZXNQZXJSb3coYml0bWFwKTsKKworICAgICAg ICAgICAgaWYgKG1fbGF5ZXJSZW5kZXJlci0+Z2V0Um9vdExheWVyVGV4dHVyZVdpZHRoKCkgPT0g d2lkdGgKKyAgICAgICAgICAgICAgICAmJiBtX2xheWVyUmVuZGVyZXItPmdldFJvb3RMYXllclRl eHR1cmVIZWlnaHQoKSA9PSBoZWlnaHQpIHsKKyAgICAgICAgICAgICAgcGl4ZWxzID0gQ0dCaXRt YXBDb250ZXh0R2V0RGF0YShiaXRtYXApOworICAgICAgICAgICAgICBtX2xheWVyUmVuZGVyZXIt PmdldEZyYW1lYnVmZmVyUGl4ZWxzKHBpeGVscywgd2lkdGgsIGhlaWdodCwgcm93Qnl0ZXMpOwor ICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICB3aWR0aCA9IG1fbGF5ZXJSZW5k ZXJlci0+Z2V0Um9vdExheWVyVGV4dHVyZVdpZHRoKCk7CisgICAgICAgICAgICAgICAgaGVpZ2h0 ID0gbV9sYXllclJlbmRlcmVyLT5nZXRSb290TGF5ZXJUZXh0dXJlSGVpZ2h0KCk7CisKKyAgICAg ICAgICAgICAgICAvLyBDcmVhdGUgdGVtcCBiaXRtYXAgb2Ygc2FtZSBzaXplIGFzIHJlbmRlcmVk IGxheWVyIHRvIGNvcHkgcGl4ZWxzIGludG8uCisgICAgICAgICAgICAgICAgQ0dDb2xvclNwYWNl UmVmIGNvbG9yU3BhY2UgPSBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VSR0IoKTsKKyAgICAgICAg ICAgICAgICBDR0NvbnRleHRSZWYgYml0bWFwMiA9IENHQml0bWFwQ29udGV4dENyZWF0ZSgwLCB3 aWR0aCwgaGVpZ2h0LCA4LCA0ICogd2lkdGgsIGNvbG9yU3BhY2UsIAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGtDR0ltYWdlQWxw aGFQcmVtdWx0aXBsaWVkTGFzdCk7CisgICAgICAgICAgICAgICAgaWYgKGJpdG1hcDIpIHsKKyAg ICAgICAgICAgICAgICAgIHBpeGVscyA9IENHQml0bWFwQ29udGV4dEdldERhdGEoYml0bWFwMik7 CisgICAgICAgICAgICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdldEZyYW1lYnVmZmVyUGl4ZWxz KHBpeGVscywgd2lkdGgsIGhlaWdodCwgcm93Qnl0ZXMpOworCisgICAgICAgICAgICAgICAgICAv LyBDb3B5IGJpdG1hcCBiYWNrIHRvIGlucHV0IGJpdG1hcC4gVGhlIGltYWdlIGlzIGludmVydGVk IGFjY29yZGluZyB0byBDRywKKyAgICAgICAgICAgICAgICAgIC8vIHNvIHNldCB1cCB0aGUgYXBw cm9wcmlhdGUgdHJhbnNmb3JtIHRvIGludmVydCB2ZXJ0aWNhbCBheGlzIGFuZCBtb3ZlIG9yaWdp bgorICAgICAgICAgICAgICAgICAgLy8gdG8gYm90dG9tIGxlZnQuCisgICAgICAgICAgICAgICAg ICBDR0NvbnRleHRTYXZlR1N0YXRlKGJpdG1hcCk7CisgICAgICAgICAgICAgICAgICBDR0NvbnRl eHRUcmFuc2xhdGVDVE0oYml0bWFwLCAwLCBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQoYml0bWFw KSk7CisgICAgICAgICAgICAgICAgICBDR0NvbnRleHRTY2FsZUNUTShiaXRtYXAsIDEuMCwgLTEu MCk7CisgICAgICAgICAgICAgICAgICBDR0NvbnRleHREcmF3SW1hZ2UoYml0bWFwLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENHUmVjdE1ha2UoMCwgMCwgQ0dCaXRtYXBD b250ZXh0R2V0V2lkdGgoYml0bWFwKSwgQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1hcCkp LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENHQml0bWFwQ29udGV4dENy ZWF0ZUltYWdlKGJpdG1hcDIpKTsKKyAgICAgICAgICAgICAgICAgIENHQ29udGV4dFJlc3RvcmVH U3RhdGUoYml0bWFwKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CisjZWxzZQor I2Vycm9yIE11c3QgcG9ydCB0byB5b3VyIHBsYXRmb3JtLgorI2VuZGlmCisgICAgICAgIH0KKwor ICAgICAgICBtX2xheWVyUmVuZGVyZXItPnByZXNlbnQoKTsgLy8gRG8gZmluYWwgZGlzcGxheSBi eSBzd2FwcGluZyBidWZmZXJzLgogICAgIH0KICNlbmRpZgogfQo= 65918 2010-08-30 08:54:37 -0700 2010-08-30 11:12:47 -0700 Patch bug-44127-20100830115457.patch text/plain 10398 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZWI1OTEwZWRhOWE0MGJmOTkwNDQ2Yzc0MWQzZDFhMjViMTYyMWFlNy4uYjE3YThlNGMyNmRkMjA3 Y2MwN2I2MTVjZGIzNzNmZmRmZmVlYzFmNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wOC0zMCAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKworICAgICAgICBBZGRz IHBpeGVsLXJlYWRiYWNrIGZvciBHUFUgY29tcG9zaXRlZCBwYWdlcyB0byBhbGxvdyBmb3IgdGh1 bWJuYWlsaW5nLAorICAgICAgICBwcmludGluZyBhbmQgb3RoZXIgc2VydmljZXMgdG8gd29yayB3 aXRoIEdQVSByZW5kZXJlZCBwYWdlcy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXll clJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpwcmVzZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVy ZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29y ZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlV2lkdGgpOgorICAgICAg ICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlSGVpZ2h0 KToKKwogMjAxMC0wOC0yNSAgSWx5YSBUaWtob25vdnNreSAgPGxvaXNsb0BjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWXVyeSBTZW1pa2hhdHNreS4KZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNw cCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9t aXVtLmNwcAppbmRleCBjZjIzODcxOGIyMWJiNDBiYjY5NzY2MjdkOWYyMzM4NTRlNDQ2OWZiLi41 Y2IxZWI3NmVkM2RmYzMzYmEyODAwNTBjZmY5ZGU0OGFiMTFkMTViIDEwMDY0NAotLS0gYS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAK KysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hy b21pdW0uY3BwCkBAIC0zMTAsMTEgKzMxMCw0MiBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1 bTo6ZHJhd0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0Jgog CiAgICAgR0xDKGdsRGlzYWJsZShHTF9TQ0lTU09SX1RFU1QpKTsKIAorICAgIGdsRmx1c2goKTsK K30KKwordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnByZXNlbnQoKQorewogICAgIG1fZ2xl czJDb250ZXh0LT5zd2FwQnVmZmVycygpOwogCiAgICAgbV9uZWVkc0Rpc3BsYXkgPSBmYWxzZTsK IH0KIAordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKHZv aWQgKnBpeGVscywgY29uc3QgaW50IHdpZHRoLCBjb25zdCBpbnQgaGVpZ2h0KQoreworICAgIEFT U0VSVCh3aWR0aCA9PSBtX3Jvb3RMYXllclRleHR1cmVXaWR0aCAmJiBoZWlnaHQgPT0gbV9yb290 TGF5ZXJUZXh0dXJlSGVpZ2h0KTsKKworICAgIGlmICghcGl4ZWxzKQorICAgICAgICByZXR1cm47 CisKKyAgICBtYWtlQ29udGV4dEN1cnJlbnQoKTsKKworICAgIEdMQyhnbFJlYWRQaXhlbHMoMCwg MCwgd2lkdGgsIGhlaWdodCwKKyAgICAgICAgICAgICAgICAgICAgIEdMX1JHQkEsIEdMX1VOU0lH TkVEX0JZVEUsIHBpeGVscykpOworCisgICAgLy8gRmxpcCBwaXhlbHMgdmVydGljYWxseS4KKyAg ICBjb25zdCBpbnQgcm93Qnl0ZXMgPSA0ICogd2lkdGg7CisgICAgT3duUHRyPHVuc2lnbmVkIGNo YXI+IGxpbmVUZW1wKG5ldyB1bnNpZ25lZCBjaGFyW3Jvd0J5dGVzXSk7CisgICAgZm9yIChpbnQg cm93MSA9IDAsIHJvdzIgPSBoZWlnaHQgLSAxOyByb3cxIDwgaGVpZ2h0IC8gMjsgKytyb3cxLCAt LXJvdzIpIHsKKworICAgICAgICB1bnNpZ25lZCBjaGFyKiBwdHIxID0gc3RhdGljX2Nhc3Q8dW5z aWduZWQgY2hhcio+KHBpeGVscykgKyByb3cxICogcm93Qnl0ZXM7CisgICAgICAgIHVuc2lnbmVk IGNoYXIqIHB0cjIgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4ocGl4ZWxzKSArIHJvdzIg KiByb3dCeXRlczsKKworICAgICAgICBtZW1jcHkobGluZVRlbXAuZ2V0KCksIHB0cjEsIHJvd0J5 dGVzKTsKKyAgICAgICAgbWVtY3B5KHB0cjEsIHB0cjIsIHJvd0J5dGVzKTsKKyAgICAgICAgbWVt Y3B5KHB0cjIsIGxpbmVUZW1wLmdldCgpLCByb3dCeXRlcyk7CisgICAgfQorfQorCiAvLyBGSVhN RTogVGhpcyBtZXRob2Qgc2hvdWxkIGV2ZW50dWFsbHkgYmUgcmVwbGFjZWQgYnkgYSBwcm9wZXIg dGV4dHVyZSBtYW5hZ2VyLgogdW5zaWduZWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpjcmVhdGVM YXllclRleHR1cmUoKQogewpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggMjRiYmU2NTI4MjhjMWY5 OGE1MzFlMjEyOGY2OTE4ZDFlOWU4YzM2My4uNjVkMzdiODdkZTVkYjAwM2NjZjM4MWVhNDA3OGE1 ODk5YjkwNjY0YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC02NCw2ICs2NCw3IEBAIHB1Ymxp YzoKICAgICAvLyBVcGRhdGVzIHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllciB0aGF0IGZh bGwgaW5zaWRlIHRoZSB1cGRhdGVSZWN0IGFuZCByZWNvbXBvc2l0ZXMKICAgICAvLyBhbGwgdGhl IGxheWVycy4KICAgICB2b2lkIGRyYXdMYXllcnMoY29uc3QgSW50UmVjdCYgdXBkYXRlUmVjdCwg Y29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0LCBj b25zdCBJbnRQb2ludCYgc2Nyb2xsUG9zaXRpb24pOworICAgIHZvaWQgcHJlc2VudCgpOyAvLyBQ ZXJmb3JtIGJ1ZmZlciBzd2FwIHRvIHByZXNlbnQgcmVuZGVyZWQgYnVmZmVyLgogCiAgICAgdm9p ZCBzZXRSb290TGF5ZXIoUGFzc1JlZlB0cjxMYXllckNocm9taXVtPiBsYXllcikgeyBtX3Jvb3RM YXllciA9IGxheWVyOyB9CiAgICAgTGF5ZXJDaHJvbWl1bSogcm9vdExheWVyKCkgeyByZXR1cm4g bV9yb290TGF5ZXIuZ2V0KCk7IH0KQEAgLTkwLDYgKzkxLDEwIEBAIHB1YmxpYzoKICAgICBjb25z dCBDb250ZW50TGF5ZXJDaHJvbWl1bTo6U2hhcmVkVmFsdWVzKiBjb250ZW50TGF5ZXJTaGFyZWRW YWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NvbnRlbnRMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsg fQogICAgIGNvbnN0IENhbnZhc0xheWVyQ2hyb21pdW06OlNoYXJlZFZhbHVlcyogY2FudmFzTGF5 ZXJTaGFyZWRWYWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NhbnZhc0xheWVyU2hhcmVkVmFsdWVz LmdldCgpOyB9CiAKKyAgICBpbnQgcm9vdExheWVyVGV4dHVyZVdpZHRoKCkgY29uc3QgeyByZXR1 cm4gbV9yb290TGF5ZXJUZXh0dXJlV2lkdGg7IH0KKyAgICBpbnQgcm9vdExheWVyVGV4dHVyZUhl aWdodCgpIGNvbnN0IHsgcmV0dXJuIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodDsgfQorICAgIHZv aWQgZ2V0RnJhbWVidWZmZXJQaXhlbHModm9pZCAqcGl4ZWxzLCBjb25zdCBpbnQgd2lkdGgsIGNv bnN0IGludCBoZWlnaHQpOworCiBwcml2YXRlOgogICAgIHZvaWQgdXBkYXRlTGF5ZXJzUmVjdXJz aXZlKExheWVyQ2hyb21pdW0qIGxheWVyLCBjb25zdCBUcmFuc2Zvcm1hdGlvbk1hdHJpeCYgcGFy ZW50TWF0cml4LCBmbG9hdCBvcGFjaXR5KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggNWQ4NjBlZDcxNDQx YzQwMTI0NmQ4ZGZjMTc3MjNlNWViZTliZmE0MS4uZDhiMjYyZjAzMzVkNzkwZjI3MWFhMGQ4ODg5 ZDk1NzQ0ZmZmMWFlNyAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysg Yi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTAtMDgtMzAg IFcuIEphbWVzIE1hY0xlYW4gIDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVGh1bWJuYWls cyBub3QgZ2VuZXJhdGVkIGZvciBHUFUgUmVuZGVyZWQgUGFnZXMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0MTI3CisKKyAgICAgICAgTW9kaWZpZWQg V2ViVmlld0ltcGw6OnBhaW50KCkgdG8gZGV0ZWN0IG5vbi1udWxsIGNhbnZhcyBwb2ludGVycyB3 aGVuCisgICAgICAgIGFjY2VsZXJhdGVkIGNvbXBvc2l0aW5nIGlzIGFjdGl2ZSwgYW5kIGluc3Rl YWQgZmlsbHMgdGhlIHBpeGVsIGJ1ZmZlcgorICAgICAgICBmcm9tIHRoZSBHUFUgZnJhbWVidWZm ZXIuIEluY2x1ZGVzIHJlLXNjYWxpbmcgc3VwcG9ydCB3aGVuIHByb3ZpZGVkCisgICAgICAgIGNh bnZhcyBkb2VzIG5vdCBtYXRjaCBzaXplIG9mIGN1cnJlbnQgcmVuZGVyIGxheWVyLgorCisgICAg ICAgICogc3JjL1dlYlZpZXdJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6 OnBhaW50KToKKwogMjAxMC0wOC0yNSAgU2F0aXNoIFNhbXBhdGggIDxzYXRpc2hAY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEplcmVteSBPcmxvdy4KZGlmZiAtLWdpdCBhL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJWaWV3SW1wbC5jcHAKaW5kZXggMzgzYjcxNjczMTRlZGFmMzQyZGFlYjQ4ZjNiNTY2MTBlZDc1 MzE0OC4uOTNlODRiNjYwYzUyZWEyNGEyNjc1NmM4MzYxNTVlODQzMWJiNzBjYiAxMDA2NDQKLS0t IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTExNSw2ICsxMTUsMTAgQEAKICNpbmNsdWRlICJX ZWJWaWV3Q2xpZW50LmgiCiAjaW5jbHVkZSAid3RmL093blB0ci5oIgogCisjaWYgUExBVEZPUk0o Q0cpCisjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NHQ29udGV4dC5oPgorI2VuZGlmCisKICNpZiBP UyhXSU5ET1dTKQogI2luY2x1ZGUgIlJlbmRlclRoZW1lQ2hyb21pdW1XaW4uaCIKICNlbHNlCkBA IC05NTUsNiArOTU5LDcgQEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52 YXMsIGNvbnN0IFdlYlJlY3QmIHJlY3QpCiAgICAgICAgICAgICB3ZWJmcmFtZS0+cGFpbnQoY2Fu dmFzLCByZWN0KTsKICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCiAgICAgfSBlbHNl IHsKKwogICAgICAgICAvLyBEcmF3IHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllci4KICAg ICAgICAgdXBkYXRlUm9vdExheWVyQ29udGVudHMocmVjdCk7CiAKQEAgLTk3MSw2ICs5NzYsODIg QEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdlYlJl Y3QmIHJlY3QpCiAKICAgICAgICAgLy8gQXNrIHRoZSBsYXllciBjb21wb3NpdG9yIHRvIHJlZHJh dyBhbGwgdGhlIGxheWVycy4KICAgICAgICAgbV9sYXllclJlbmRlcmVyLT5kcmF3TGF5ZXJzKHJl Y3QsIHZpc2libGVSZWN0LCBjb250ZW50UmVjdCwgSW50UG9pbnQodmlldy0+c2Nyb2xsWCgpLCB2 aWV3LT5zY3JvbGxZKCkpKTsKKworICAgICAgICAvLyBJZiBhIGNhbnZhcyB3YXMgcGFzc2VkIGlu LCB3ZSB1c2UgaXQgdG8gZ3JhYiBhIGNvcHkgb2YgdGhlCisgICAgICAgIC8vIGZyZXNobHktcmVu ZGVyZWQgcGl4ZWxzLgorICAgICAgICBpZiAoY2FudmFzKSB7CisgICAgICAgICAgICB2b2lkKiBw aXhlbHMgPSAwOworI2lmIFBMQVRGT1JNKFNLSUEpCisgICAgICAgICAgICBjb25zdCBTa0JpdG1h cCBiaXRtYXAgPSBjYW52YXMtPmdldERldmljZSgpLT5hY2Nlc3NCaXRtYXAoZmFsc2UpOworICAg ICAgICAgICAgQVNTRVJUKGJpdG1hcC5jb25maWcoKSA9PSBTa0JpdG1hcDo6a0FSR0JfODg4OF9D b25maWcpOworCisgICAgICAgICAgICBpbnQgd2lkdGggPSBiaXRtYXAud2lkdGgoKTsKKyAgICAg ICAgICAgIGludCBoZWlnaHQgPSBiaXRtYXAuaGVpZ2h0KCk7CisKKyAgICAgICAgICAgIFNrQXV0 b0xvY2tQaXhlbHMgYml0bWFwTG9jayhiaXRtYXApOworCisgICAgICAgICAgICBpZiAobV9sYXll clJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlV2lkdGgoKSA9PSB3aWR0aAorICAgICAgICAgICAg ICAgICYmIG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZUhlaWdodCgpID09IGhlaWdo dCkgeworICAgICAgICAgICAgICAgIHBpeGVscyA9IGJpdG1hcC5nZXRQaXhlbHMoKTsKKyAgICAg ICAgICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdldEZyYW1lYnVmZmVyUGl4ZWxzKHBpeGVscywg d2lkdGgsIGhlaWdodCk7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIGlu dCB3aWR0aFJlc2l6ZSA9IG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVdpZHRoKCk7 CisgICAgICAgICAgICAgICAgaW50IGhlaWdodFJlc2l6ZSA9IG1fbGF5ZXJSZW5kZXJlci0+cm9v dExheWVyVGV4dHVyZUhlaWdodCgpOworCisgICAgICAgICAgICAgICAgLy8gQ3JlYXRlIHRlbXAg Yml0bWFwIG9mIGNvcnJlY3Qgc2l6ZSB0byBjb3B5IHBpeGVscyBpbnRvLgorICAgICAgICAgICAg ICAgIE93blB0cjxza2lhOjpQbGF0Zm9ybUNhbnZhcz4gY2FudmFzUmVzaXplID0gT3duUHRyPHNr aWE6OlBsYXRmb3JtQ2FudmFzPihuZXcgc2tpYTo6UGxhdGZvcm1DYW52YXMoKSk7CisgICAgICAg ICAgICAgICAgaWYgKGNhbnZhc1Jlc2l6ZS5nZXQoKSAmJiBjYW52YXNSZXNpemUtPmluaXRpYWxp emUod2lkdGhSZXNpemUsIGhlaWdodFJlc2l6ZSwgdHJ1ZSkpIHsKKyAgICAgICAgICAgICAgICAg ICAgU2tCaXRtYXAgYml0bWFwUmVzaXplID0gY2FudmFzUmVzaXplLT5nZXREZXZpY2UoKS0+YWNj ZXNzQml0bWFwKGZhbHNlKTsKKyAgICAgICAgICAgICAgICAgICAgcGl4ZWxzID0gYml0bWFwUmVz aXplLmdldFBpeGVscygpOworICAgICAgICAgICAgICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdl dEZyYW1lYnVmZmVyUGl4ZWxzKHBpeGVscywgd2lkdGhSZXNpemUsIGhlaWdodFJlc2l6ZSk7Cisg ICAgICAgICAgICAgICAgICAgIFNrSVJlY3Qgc3JjUmVjdDsKKyAgICAgICAgICAgICAgICAgICAg c3JjUmVjdC5zZXQoMCwgMCwgYml0bWFwUmVzaXplLndpZHRoKCksIGJpdG1hcFJlc2l6ZS5oZWln aHQoKSk7CisgICAgICAgICAgICAgICAgICAgIFNrUmVjdCBkc3RSZWN0ID0gU2tSZWN0OjpNYWtl V0goYml0bWFwLndpZHRoKCksIGJpdG1hcC5oZWlnaHQoKSk7CisgICAgICAgICAgICAgICAgICAg IGNhbnZhcy0+ZHJhd0JpdG1hcFJlY3QoYml0bWFwUmVzaXplLCAmc3JjUmVjdCwgZHN0UmVjdCwg MCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorI2VsaWYgUExBVEZPUk0oQ0cp CisgICAgICAgICAgICBDR0NvbnRleHRSZWYgYml0bWFwID0gcmVpbnRlcnByZXRfY2FzdDxDR0Nv bnRleHRSZWY+KGNhbnZhcyk7CisgICAgICAgICAgICBBU1NFUlQoQ0dCaXRtYXBDb250ZXh0R2V0 Um93Qnl0ZXMoYml0bWFwKSA9PSA0ICogd2lkdGgpOworCisgICAgICAgICAgICBpbnQgd2lkdGgg PSBDR0JpdG1hcENvbnRleHRHZXRXaWR0aChiaXRtYXApOworICAgICAgICAgICAgaW50IGhlaWdo dCA9IENHQml0bWFwQ29udGV4dEdldEhlaWdodChiaXRtYXApOworCisgICAgICAgICAgICBpZiAo bV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlV2lkdGgoKSA9PSB3aWR0aAorICAgICAg ICAgICAgICAgICYmIG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZUhlaWdodCgpID09 IGhlaWdodCkgeworICAgICAgICAgICAgICBwaXhlbHMgPSBDR0JpdG1hcENvbnRleHRHZXREYXRh KGJpdG1hcCk7CisgICAgICAgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQ aXhlbHMocGl4ZWxzLCB3aWR0aCwgaGVpZ2h0KTsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAg ICAgICAgICAgICAgaW50IHdpZHRoUmVzaXplID0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJU ZXh0dXJlV2lkdGgoKTsKKyAgICAgICAgICAgICAgICBpbnQgaGVpZ2h0UmVzaXplID0gbV9sYXll clJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlSGVpZ2h0KCk7CisKKyAgICAgICAgICAgICAgICAv LyBDcmVhdGUgdGVtcCBiaXRtYXAgb2Ygc2FtZSBzaXplIGFzIHJlbmRlcmVkIGxheWVyIHRvIGNv cHkgcGl4ZWxzIGludG8uCisgICAgICAgICAgICAgICAgQ0dDb2xvclNwYWNlUmVmIGNvbG9yU3Bh Y2UgPSBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VSR0IoKTsKKyAgICAgICAgICAgICAgICBDR0Nv bnRleHRSZWYgYml0bWFwUmVzaXplID0gQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKDAsIHdpZHRoUmVz aXplLCBoZWlnaHRSZXNpemUsIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOCwgNCAqIHdpZHRoUmVzaXplLCBjb2xvclNw YWNlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRMYXN0KTsKKyAgICAgICAg ICAgICAgICBpZiAoYml0bWFwUmVzaXplKSB7CisgICAgICAgICAgICAgICAgICBwaXhlbHMgPSBD R0JpdG1hcENvbnRleHRHZXREYXRhKGJpdG1hcFJlc2l6ZSk7CisgICAgICAgICAgICAgICAgICBt X2xheWVyUmVuZGVyZXItPmdldEZyYW1lYnVmZmVyUGl4ZWxzKHBpeGVscywgd2lkdGhSZXNpemUs IGhlaWdodFJlc2l6ZSk7CisKKyAgICAgICAgICAgICAgICAgIC8vIENvcHkgYml0bWFwIGJhY2sg dG8gaW5wdXQgYml0bWFwLiBUaGUgaW1hZ2UgaXMgaW52ZXJ0ZWQgYWNjb3JkaW5nIHRvIENHLAor ICAgICAgICAgICAgICAgICAgLy8gc28gc2V0IHVwIHRoZSBhcHByb3ByaWF0ZSB0cmFuc2Zvcm0g dG8gaW52ZXJ0IHZlcnRpY2FsIGF4aXMgYW5kIG1vdmUgb3JpZ2luCisgICAgICAgICAgICAgICAg ICAvLyB0byBib3R0b20gbGVmdC4KKyAgICAgICAgICAgICAgICAgIENHQ29udGV4dFNhdmVHU3Rh dGUoYml0bWFwKTsKKyAgICAgICAgICAgICAgICAgIENHQ29udGV4dFRyYW5zbGF0ZUNUTShiaXRt YXAsIDAsIENHQml0bWFwQ29udGV4dEdldEhlaWdodChiaXRtYXApKTsKKyAgICAgICAgICAgICAg ICAgIENHQ29udGV4dFNjYWxlQ1RNKGJpdG1hcCwgMS4wLCAtMS4wKTsKKyAgICAgICAgICAgICAg ICAgIENHQ29udGV4dERyYXdJbWFnZShiaXRtYXAsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgQ0dSZWN0TWFrZSgwLCAwLCBDR0JpdG1hcENvbnRleHRHZXRXaWR0aChiaXRt YXApLCBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQoYml0bWFwKSksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlSW1hZ2UoYml0bWFwUmVz aXplKSk7CisgICAgICAgICAgICAgICAgICBDR0NvbnRleHRSZXN0b3JlR1N0YXRlKGJpdG1hcCk7 CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorI2Vsc2UKKyNlcnJvciBNdXN0IHBv cnQgdG8geW91ciBwbGF0Zm9ybS4KKyNlbmRpZgorICAgICAgICB9CisKKyAgICAgICAgbV9sYXll clJlbmRlcmVyLT5wcmVzZW50KCk7IC8vIERvIGZpbmFsIGRpc3BsYXkgYnkgc3dhcHBpbmcgYnVm ZmVycy4KICAgICB9CiAjZW5kaWYKIH0K 65932 2010-08-30 11:12:52 -0700 2010-08-30 12:54:26 -0700 Patch bug-44127-20100830141312.patch text/plain 10750 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZWI1OTEwZWRhOWE0MGJmOTkwNDQ2Yzc0MWQzZDFhMjViMTYyMWFlNy4uYjE3YThlNGMyNmRkMjA3 Y2MwN2I2MTVjZGIzNzNmZmRmZmVlYzFmNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wOC0zMCAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKworICAgICAgICBBZGRz IHBpeGVsLXJlYWRiYWNrIGZvciBHUFUgY29tcG9zaXRlZCBwYWdlcyB0byBhbGxvdyBmb3IgdGh1 bWJuYWlsaW5nLAorICAgICAgICBwcmludGluZyBhbmQgb3RoZXIgc2VydmljZXMgdG8gd29yayB3 aXRoIEdQVSByZW5kZXJlZCBwYWdlcy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXll clJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpwcmVzZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVy ZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29y ZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlV2lkdGgpOgorICAgICAg ICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlSGVpZ2h0 KToKKwogMjAxMC0wOC0yNSAgSWx5YSBUaWtob25vdnNreSAgPGxvaXNsb0BjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWXVyeSBTZW1pa2hhdHNreS4KZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNw cCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9t aXVtLmNwcAppbmRleCBjZjIzODcxOGIyMWJiNDBiYjY5NzY2MjdkOWYyMzM4NTRlNDQ2OWZiLi41 Y2IxZWI3NmVkM2RmYzMzYmEyODAwNTBjZmY5ZGU0OGFiMTFkMTViIDEwMDY0NAotLS0gYS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAK KysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hy b21pdW0uY3BwCkBAIC0zMTAsMTEgKzMxMCw0MiBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1 bTo6ZHJhd0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0Jgog CiAgICAgR0xDKGdsRGlzYWJsZShHTF9TQ0lTU09SX1RFU1QpKTsKIAorICAgIGdsRmx1c2goKTsK K30KKwordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnByZXNlbnQoKQorewogICAgIG1fZ2xl czJDb250ZXh0LT5zd2FwQnVmZmVycygpOwogCiAgICAgbV9uZWVkc0Rpc3BsYXkgPSBmYWxzZTsK IH0KIAordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKHZv aWQgKnBpeGVscywgY29uc3QgaW50IHdpZHRoLCBjb25zdCBpbnQgaGVpZ2h0KQoreworICAgIEFT U0VSVCh3aWR0aCA9PSBtX3Jvb3RMYXllclRleHR1cmVXaWR0aCAmJiBoZWlnaHQgPT0gbV9yb290 TGF5ZXJUZXh0dXJlSGVpZ2h0KTsKKworICAgIGlmICghcGl4ZWxzKQorICAgICAgICByZXR1cm47 CisKKyAgICBtYWtlQ29udGV4dEN1cnJlbnQoKTsKKworICAgIEdMQyhnbFJlYWRQaXhlbHMoMCwg MCwgd2lkdGgsIGhlaWdodCwKKyAgICAgICAgICAgICAgICAgICAgIEdMX1JHQkEsIEdMX1VOU0lH TkVEX0JZVEUsIHBpeGVscykpOworCisgICAgLy8gRmxpcCBwaXhlbHMgdmVydGljYWxseS4KKyAg ICBjb25zdCBpbnQgcm93Qnl0ZXMgPSA0ICogd2lkdGg7CisgICAgT3duUHRyPHVuc2lnbmVkIGNo YXI+IGxpbmVUZW1wKG5ldyB1bnNpZ25lZCBjaGFyW3Jvd0J5dGVzXSk7CisgICAgZm9yIChpbnQg cm93MSA9IDAsIHJvdzIgPSBoZWlnaHQgLSAxOyByb3cxIDwgaGVpZ2h0IC8gMjsgKytyb3cxLCAt LXJvdzIpIHsKKworICAgICAgICB1bnNpZ25lZCBjaGFyKiBwdHIxID0gc3RhdGljX2Nhc3Q8dW5z aWduZWQgY2hhcio+KHBpeGVscykgKyByb3cxICogcm93Qnl0ZXM7CisgICAgICAgIHVuc2lnbmVk IGNoYXIqIHB0cjIgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4ocGl4ZWxzKSArIHJvdzIg KiByb3dCeXRlczsKKworICAgICAgICBtZW1jcHkobGluZVRlbXAuZ2V0KCksIHB0cjEsIHJvd0J5 dGVzKTsKKyAgICAgICAgbWVtY3B5KHB0cjEsIHB0cjIsIHJvd0J5dGVzKTsKKyAgICAgICAgbWVt Y3B5KHB0cjIsIGxpbmVUZW1wLmdldCgpLCByb3dCeXRlcyk7CisgICAgfQorfQorCiAvLyBGSVhN RTogVGhpcyBtZXRob2Qgc2hvdWxkIGV2ZW50dWFsbHkgYmUgcmVwbGFjZWQgYnkgYSBwcm9wZXIg dGV4dHVyZSBtYW5hZ2VyLgogdW5zaWduZWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpjcmVhdGVM YXllclRleHR1cmUoKQogewpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggMjRiYmU2NTI4MjhjMWY5 OGE1MzFlMjEyOGY2OTE4ZDFlOWU4YzM2My4uNjVkMzdiODdkZTVkYjAwM2NjZjM4MWVhNDA3OGE1 ODk5YjkwNjY0YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC02NCw2ICs2NCw3IEBAIHB1Ymxp YzoKICAgICAvLyBVcGRhdGVzIHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllciB0aGF0IGZh bGwgaW5zaWRlIHRoZSB1cGRhdGVSZWN0IGFuZCByZWNvbXBvc2l0ZXMKICAgICAvLyBhbGwgdGhl IGxheWVycy4KICAgICB2b2lkIGRyYXdMYXllcnMoY29uc3QgSW50UmVjdCYgdXBkYXRlUmVjdCwg Y29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0LCBj b25zdCBJbnRQb2ludCYgc2Nyb2xsUG9zaXRpb24pOworICAgIHZvaWQgcHJlc2VudCgpOyAvLyBQ ZXJmb3JtIGJ1ZmZlciBzd2FwIHRvIHByZXNlbnQgcmVuZGVyZWQgYnVmZmVyLgogCiAgICAgdm9p ZCBzZXRSb290TGF5ZXIoUGFzc1JlZlB0cjxMYXllckNocm9taXVtPiBsYXllcikgeyBtX3Jvb3RM YXllciA9IGxheWVyOyB9CiAgICAgTGF5ZXJDaHJvbWl1bSogcm9vdExheWVyKCkgeyByZXR1cm4g bV9yb290TGF5ZXIuZ2V0KCk7IH0KQEAgLTkwLDYgKzkxLDEwIEBAIHB1YmxpYzoKICAgICBjb25z dCBDb250ZW50TGF5ZXJDaHJvbWl1bTo6U2hhcmVkVmFsdWVzKiBjb250ZW50TGF5ZXJTaGFyZWRW YWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NvbnRlbnRMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsg fQogICAgIGNvbnN0IENhbnZhc0xheWVyQ2hyb21pdW06OlNoYXJlZFZhbHVlcyogY2FudmFzTGF5 ZXJTaGFyZWRWYWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NhbnZhc0xheWVyU2hhcmVkVmFsdWVz LmdldCgpOyB9CiAKKyAgICBpbnQgcm9vdExheWVyVGV4dHVyZVdpZHRoKCkgY29uc3QgeyByZXR1 cm4gbV9yb290TGF5ZXJUZXh0dXJlV2lkdGg7IH0KKyAgICBpbnQgcm9vdExheWVyVGV4dHVyZUhl aWdodCgpIGNvbnN0IHsgcmV0dXJuIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodDsgfQorICAgIHZv aWQgZ2V0RnJhbWVidWZmZXJQaXhlbHModm9pZCAqcGl4ZWxzLCBjb25zdCBpbnQgd2lkdGgsIGNv bnN0IGludCBoZWlnaHQpOworCiBwcml2YXRlOgogICAgIHZvaWQgdXBkYXRlTGF5ZXJzUmVjdXJz aXZlKExheWVyQ2hyb21pdW0qIGxheWVyLCBjb25zdCBUcmFuc2Zvcm1hdGlvbk1hdHJpeCYgcGFy ZW50TWF0cml4LCBmbG9hdCBvcGFjaXR5KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggNWQ4NjBlZDcxNDQx YzQwMTI0NmQ4ZGZjMTc3MjNlNWViZTliZmE0MS4uZDhiMjYyZjAzMzVkNzkwZjI3MWFhMGQ4ODg5 ZDk1NzQ0ZmZmMWFlNyAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysg Yi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTAtMDgtMzAg IFcuIEphbWVzIE1hY0xlYW4gIDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVGh1bWJuYWls cyBub3QgZ2VuZXJhdGVkIGZvciBHUFUgUmVuZGVyZWQgUGFnZXMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0MTI3CisKKyAgICAgICAgTW9kaWZpZWQg V2ViVmlld0ltcGw6OnBhaW50KCkgdG8gZGV0ZWN0IG5vbi1udWxsIGNhbnZhcyBwb2ludGVycyB3 aGVuCisgICAgICAgIGFjY2VsZXJhdGVkIGNvbXBvc2l0aW5nIGlzIGFjdGl2ZSwgYW5kIGluc3Rl YWQgZmlsbHMgdGhlIHBpeGVsIGJ1ZmZlcgorICAgICAgICBmcm9tIHRoZSBHUFUgZnJhbWVidWZm ZXIuIEluY2x1ZGVzIHJlLXNjYWxpbmcgc3VwcG9ydCB3aGVuIHByb3ZpZGVkCisgICAgICAgIGNh bnZhcyBkb2VzIG5vdCBtYXRjaCBzaXplIG9mIGN1cnJlbnQgcmVuZGVyIGxheWVyLgorCisgICAg ICAgICogc3JjL1dlYlZpZXdJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6 OnBhaW50KToKKwogMjAxMC0wOC0yNSAgU2F0aXNoIFNhbXBhdGggIDxzYXRpc2hAY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEplcmVteSBPcmxvdy4KZGlmZiAtLWdpdCBhL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJWaWV3SW1wbC5jcHAKaW5kZXggMzgzYjcxNjczMTRlZGFmMzQyZGFlYjQ4ZjNiNTY2MTBlZDc1 MzE0OC4uZjA3Mzk5YWE0YTY5NjZjNGNiOTczYmRmMGI5ZDY0MjVkM2RjMjMxZSAxMDA2NDQKLS0t IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTExNSw2ICsxMTUsMTAgQEAKICNpbmNsdWRlICJX ZWJWaWV3Q2xpZW50LmgiCiAjaW5jbHVkZSAid3RmL093blB0ci5oIgogCisjaWYgUExBVEZPUk0o Q0cpCisjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NHQ29udGV4dC5oPgorI2VuZGlmCisKICNpZiBP UyhXSU5ET1dTKQogI2luY2x1ZGUgIlJlbmRlclRoZW1lQ2hyb21pdW1XaW4uaCIKICNlbHNlCkBA IC05NTUsNiArOTU5LDcgQEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52 YXMsIGNvbnN0IFdlYlJlY3QmIHJlY3QpCiAgICAgICAgICAgICB3ZWJmcmFtZS0+cGFpbnQoY2Fu dmFzLCByZWN0KTsKICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCiAgICAgfSBlbHNl IHsKKwogICAgICAgICAvLyBEcmF3IHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllci4KICAg ICAgICAgdXBkYXRlUm9vdExheWVyQ29udGVudHMocmVjdCk7CiAKQEAgLTk3MSw2ICs5NzYsODgg QEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdlYlJl Y3QmIHJlY3QpCiAKICAgICAgICAgLy8gQXNrIHRoZSBsYXllciBjb21wb3NpdG9yIHRvIHJlZHJh dyBhbGwgdGhlIGxheWVycy4KICAgICAgICAgbV9sYXllclJlbmRlcmVyLT5kcmF3TGF5ZXJzKHJl Y3QsIHZpc2libGVSZWN0LCBjb250ZW50UmVjdCwgSW50UG9pbnQodmlldy0+c2Nyb2xsWCgpLCB2 aWV3LT5zY3JvbGxZKCkpKTsKKworICAgICAgICAvLyBJZiBhIGNhbnZhcyB3YXMgcGFzc2VkIGlu LCB3ZSB1c2UgaXQgdG8gZ3JhYiBhIGNvcHkgb2YgdGhlCisgICAgICAgIC8vIGZyZXNobHktcmVu ZGVyZWQgcGl4ZWxzLgorICAgICAgICBpZiAoY2FudmFzKSB7CisgICAgICAgICAgICB2b2lkKiBw aXhlbHMgPSAwOworI2lmIFBMQVRGT1JNKFNLSUEpCisgICAgICAgICAgICBjb25zdCBTa0JpdG1h cCBiaXRtYXAgPSBjYW52YXMtPmdldERldmljZSgpLT5hY2Nlc3NCaXRtYXAoZmFsc2UpOworICAg ICAgICAgICAgaWYgKGJpdG1hcC5jb25maWcoKSA9PSBTa0JpdG1hcDo6a0FSR0JfODg4OF9Db25m aWcpIHsKKworICAgICAgICAgICAgICAgIGludCB3aWR0aCA9IGJpdG1hcC53aWR0aCgpOworICAg ICAgICAgICAgICAgIGludCBoZWlnaHQgPSBiaXRtYXAuaGVpZ2h0KCk7CisKKyAgICAgICAgICAg ICAgICBTa0F1dG9Mb2NrUGl4ZWxzIGJpdG1hcExvY2soYml0bWFwKTsKKworICAgICAgICAgICAg ICAgIGlmIChtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVXaWR0aCgpID09IHdpZHRo CisgICAgICAgICAgICAgICAgICAgICYmIG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVy ZUhlaWdodCgpID09IGhlaWdodCkgeworICAgICAgICAgICAgICAgICAgICBwaXhlbHMgPSBiaXRt YXAuZ2V0UGl4ZWxzKCk7CisgICAgICAgICAgICAgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0 RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCB3aWR0aCwgaGVpZ2h0KTsKKyAgICAgICAgICAgICAg ICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpbnQgd2lkdGhSZXNpemUgPSBtX2xheWVy UmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVXaWR0aCgpOworICAgICAgICAgICAgICAgICAgICBp bnQgaGVpZ2h0UmVzaXplID0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlSGVpZ2h0 KCk7CisKKyAgICAgICAgICAgICAgICAgICAgLy8gQ3JlYXRlIHRlbXAgYml0bWFwIG9mIGNvcnJl Y3Qgc2l6ZSB0byBjb3B5IHBpeGVscyBpbnRvLgorICAgICAgICAgICAgICAgICAgICBPd25QdHI8 c2tpYTo6UGxhdGZvcm1DYW52YXM+IGNhbnZhc1Jlc2l6ZSA9IE93blB0cjxza2lhOjpQbGF0Zm9y bUNhbnZhcz4obmV3IHNraWE6OlBsYXRmb3JtQ2FudmFzKCkpOworICAgICAgICAgICAgICAgICAg ICBpZiAoY2FudmFzUmVzaXplLmdldCgpICYmIGNhbnZhc1Jlc2l6ZS0+aW5pdGlhbGl6ZSh3aWR0 aFJlc2l6ZSwgaGVpZ2h0UmVzaXplLCB0cnVlKSkgeworICAgICAgICAgICAgICAgICAgICAgICAg U2tCaXRtYXAgYml0bWFwUmVzaXplID0gY2FudmFzUmVzaXplLT5nZXREZXZpY2UoKS0+YWNjZXNz Qml0bWFwKGZhbHNlKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHBpeGVscyA9IGJpdG1hcFJl c2l6ZS5nZXRQaXhlbHMoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIG1fbGF5ZXJSZW5kZXJl ci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCB3aWR0aFJlc2l6ZSwgaGVpZ2h0UmVzaXpl KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIFNrSVJlY3Qgc3JjUmVjdDsKKyAgICAgICAgICAg ICAgICAgICAgICAgIHNyY1JlY3Quc2V0KDAsIDAsIGJpdG1hcFJlc2l6ZS53aWR0aCgpLCBiaXRt YXBSZXNpemUuaGVpZ2h0KCkpOworICAgICAgICAgICAgICAgICAgICAgICAgU2tSZWN0IGRzdFJl Y3QgPSBTa1JlY3Q6Ok1ha2VXSChiaXRtYXAud2lkdGgoKSwgYml0bWFwLmhlaWdodCgpKTsKKyAg ICAgICAgICAgICAgICAgICAgICAgIGNhbnZhcy0+ZHJhd0JpdG1hcFJlY3QoYml0bWFwUmVzaXpl LCAmc3JjUmVjdCwgZHN0UmVjdCwgMCk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIEFTU0VSVF9O T1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgfQorI2VsaWYgUExBVEZPUk0oQ0cpCisgICAgICAg ICAgICBDR0NvbnRleHRSZWYgYml0bWFwID0gcmVpbnRlcnByZXRfY2FzdDxDR0NvbnRleHRSZWY+ KGNhbnZhcyk7CisgICAgICAgICAgICBpZiAoQ0dCaXRtYXBDb250ZXh0R2V0Um93Qnl0ZXMoYml0 bWFwKSA9PSA0ICogd2lkdGgpIHsKKworICAgICAgICAgICAgICAgIGludCB3aWR0aCA9IENHQml0 bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcCk7CisgICAgICAgICAgICAgICAgaW50IGhlaWdodCA9 IENHQml0bWFwQ29udGV4dEdldEhlaWdodChiaXRtYXApOworCisgICAgICAgICAgICAgICAgaWYg KG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVdpZHRoKCkgPT0gd2lkdGgKKyAgICAg ICAgICAgICAgICAgICAgJiYgbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlSGVpZ2h0 KCkgPT0gaGVpZ2h0KSB7CisgICAgICAgICAgICAgICAgICBwaXhlbHMgPSBDR0JpdG1hcENvbnRl eHRHZXREYXRhKGJpdG1hcCk7CisgICAgICAgICAgICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdl dEZyYW1lYnVmZmVyUGl4ZWxzKHBpeGVscywgd2lkdGgsIGhlaWdodCk7CisgICAgICAgICAgICAg ICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAgICAgaW50IHdpZHRoUmVzaXplID0gbV9sYXll clJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlV2lkdGgoKTsKKyAgICAgICAgICAgICAgICAgICAg aW50IGhlaWdodFJlc2l6ZSA9IG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZUhlaWdo dCgpOworCisgICAgICAgICAgICAgICAgICAgIC8vIENyZWF0ZSB0ZW1wIGJpdG1hcCBvZiBzYW1l IHNpemUgYXMgcmVuZGVyZWQgbGF5ZXIgdG8gY29weSBwaXhlbHMgaW50by4KKyAgICAgICAgICAg ICAgICAgICAgQ0dDb2xvclNwYWNlUmVmIGNvbG9yU3BhY2UgPSBDR0NvbG9yU3BhY2VDcmVhdGVE ZXZpY2VSR0IoKTsKKyAgICAgICAgICAgICAgICAgICAgQ0dDb250ZXh0UmVmIGJpdG1hcFJlc2l6 ZSA9IENHQml0bWFwQ29udGV4dENyZWF0ZSgwLCB3aWR0aFJlc2l6ZSwgaGVpZ2h0UmVzaXplLCAK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICA4LCA0ICogd2lkdGhSZXNpemUsIGNvbG9yU3BhY2UsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRMYXN0KTsKKyAgICAgICAgICAgICAgICAgICAg aWYgKGJpdG1hcFJlc2l6ZSkgeworICAgICAgICAgICAgICAgICAgICAgIHBpeGVscyA9IENHQml0 bWFwQ29udGV4dEdldERhdGEoYml0bWFwUmVzaXplKTsKKyAgICAgICAgICAgICAgICAgICAgICBt X2xheWVyUmVuZGVyZXItPmdldEZyYW1lYnVmZmVyUGl4ZWxzKHBpeGVscywgd2lkdGhSZXNpemUs IGhlaWdodFJlc2l6ZSk7CisKKyAgICAgICAgICAgICAgICAgICAgICAvLyBDb3B5IGJpdG1hcCBi YWNrIHRvIGlucHV0IGJpdG1hcC4gVGhlIGltYWdlIGlzIGludmVydGVkIGFjY29yZGluZyB0byBD RywKKyAgICAgICAgICAgICAgICAgICAgICAvLyBzbyBzZXQgdXAgdGhlIGFwcHJvcHJpYXRlIHRy YW5zZm9ybSB0byBpbnZlcnQgdmVydGljYWwgYXhpcyBhbmQgbW92ZSBvcmlnaW4KKyAgICAgICAg ICAgICAgICAgICAgICAvLyB0byBib3R0b20gbGVmdC4KKyAgICAgICAgICAgICAgICAgICAgICBD R0NvbnRleHRTYXZlR1N0YXRlKGJpdG1hcCk7CisgICAgICAgICAgICAgICAgICAgICAgQ0dDb250 ZXh0VHJhbnNsYXRlQ1RNKGJpdG1hcCwgMCwgQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1h cCkpOworICAgICAgICAgICAgICAgICAgICAgIENHQ29udGV4dFNjYWxlQ1RNKGJpdG1hcCwgMS4w LCAtMS4wKTsKKyAgICAgICAgICAgICAgICAgICAgICBDR0NvbnRleHREcmF3SW1hZ2UoYml0bWFw LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDR1JlY3RNYWtlKDAs IDAsIENHQml0bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcCksIENHQml0bWFwQ29udGV4dEdldEhl aWdodChiaXRtYXApKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Q0dCaXRtYXBDb250ZXh0Q3JlYXRlSW1hZ2UoYml0bWFwUmVzaXplKSk7CisgICAgICAgICAgICAg ICAgICAgICAgQ0dDb250ZXh0UmVzdG9yZUdTdGF0ZShiaXRtYXApOworICAgICAgICAgICAgICAg ICAgICB9CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAg ICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgICAgIH0KKyNlbHNlCisjZXJy b3IgTXVzdCBwb3J0IHRvIHlvdXIgcGxhdGZvcm0uCisjZW5kaWYKKyAgICAgICAgfQorCisgICAg ICAgIG1fbGF5ZXJSZW5kZXJlci0+cHJlc2VudCgpOyAvLyBEbyBmaW5hbCBkaXNwbGF5IGJ5IHN3 YXBwaW5nIGJ1ZmZlcnMuCiAgICAgfQogI2VuZGlmCiB9Cg== 65943 2010-08-30 12:54:31 -0700 2010-08-30 12:56:31 -0700 Patch bug-44127-20100830155452.patch text/plain 10647 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZWI1OTEwZWRhOWE0MGJmOTkwNDQ2Yzc0MWQzZDFhMjViMTYyMWFlNy4uNjM4MGU4MjFiNjc0YTI4 ZTEzMzllNDViYWQ0ODRiNmFlZDFmZmZkMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAorMjAxMC0wOC0zMCAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBObyBuZXcgdGVzdHMu IChPT1BTISkKKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVu ZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVyQ2hyb21p dW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVt OjpwcmVzZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6Z2V0 RnJhbWVidWZmZXJQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJl ckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlV2lkdGgpOgorICAgICAgICAoV2ViQ29yZTo6TGF5 ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlSGVpZ2h0KToKKwogMjAxMC0wOC0y NSAgSWx5YSBUaWtob25vdnNreSAgPGxvaXNsb0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgWXVyeSBTZW1pa2hhdHNreS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcCBiL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcAppbmRleCBj ZjIzODcxOGIyMWJiNDBiYjY5NzY2MjdkOWYyMzM4NTRlNDQ2OWZiLi41Y2IxZWI3NmVkM2RmYzMz YmEyODAwNTBjZmY5ZGU0OGFiMTFkMTViIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKKysrIGIvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCkBAIC0z MTAsMTEgKzMxMCw0MiBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6ZHJhd0xheWVycyhj b25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0JgogCiAgICAgR0xDKGdsRGlz YWJsZShHTF9TQ0lTU09SX1RFU1QpKTsKIAorICAgIGdsRmx1c2goKTsKK30KKwordm9pZCBMYXll clJlbmRlcmVyQ2hyb21pdW06OnByZXNlbnQoKQorewogICAgIG1fZ2xlczJDb250ZXh0LT5zd2Fw QnVmZmVycygpOwogCiAgICAgbV9uZWVkc0Rpc3BsYXkgPSBmYWxzZTsKIH0KIAordm9pZCBMYXll clJlbmRlcmVyQ2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29u c3QgaW50IHdpZHRoLCBjb25zdCBpbnQgaGVpZ2h0KQoreworICAgIEFTU0VSVCh3aWR0aCA9PSBt X3Jvb3RMYXllclRleHR1cmVXaWR0aCAmJiBoZWlnaHQgPT0gbV9yb290TGF5ZXJUZXh0dXJlSGVp Z2h0KTsKKworICAgIGlmICghcGl4ZWxzKQorICAgICAgICByZXR1cm47CisKKyAgICBtYWtlQ29u dGV4dEN1cnJlbnQoKTsKKworICAgIEdMQyhnbFJlYWRQaXhlbHMoMCwgMCwgd2lkdGgsIGhlaWdo dCwKKyAgICAgICAgICAgICAgICAgICAgIEdMX1JHQkEsIEdMX1VOU0lHTkVEX0JZVEUsIHBpeGVs cykpOworCisgICAgLy8gRmxpcCBwaXhlbHMgdmVydGljYWxseS4KKyAgICBjb25zdCBpbnQgcm93 Qnl0ZXMgPSA0ICogd2lkdGg7CisgICAgT3duUHRyPHVuc2lnbmVkIGNoYXI+IGxpbmVUZW1wKG5l dyB1bnNpZ25lZCBjaGFyW3Jvd0J5dGVzXSk7CisgICAgZm9yIChpbnQgcm93MSA9IDAsIHJvdzIg PSBoZWlnaHQgLSAxOyByb3cxIDwgaGVpZ2h0IC8gMjsgKytyb3cxLCAtLXJvdzIpIHsKKworICAg ICAgICB1bnNpZ25lZCBjaGFyKiBwdHIxID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcio+KHBp eGVscykgKyByb3cxICogcm93Qnl0ZXM7CisgICAgICAgIHVuc2lnbmVkIGNoYXIqIHB0cjIgPSBz dGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4ocGl4ZWxzKSArIHJvdzIgKiByb3dCeXRlczsKKwor ICAgICAgICBtZW1jcHkobGluZVRlbXAuZ2V0KCksIHB0cjEsIHJvd0J5dGVzKTsKKyAgICAgICAg bWVtY3B5KHB0cjEsIHB0cjIsIHJvd0J5dGVzKTsKKyAgICAgICAgbWVtY3B5KHB0cjIsIGxpbmVU ZW1wLmdldCgpLCByb3dCeXRlcyk7CisgICAgfQorfQorCiAvLyBGSVhNRTogVGhpcyBtZXRob2Qg c2hvdWxkIGV2ZW50dWFsbHkgYmUgcmVwbGFjZWQgYnkgYSBwcm9wZXIgdGV4dHVyZSBtYW5hZ2Vy LgogdW5zaWduZWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpjcmVhdGVMYXllclRleHR1cmUoKQog ewpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJl bmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5 ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggMjRiYmU2NTI4MjhjMWY5OGE1MzFlMjEyOGY2OTE4 ZDFlOWU4YzM2My4uNjVkMzdiODdkZTVkYjAwM2NjZjM4MWVhNDA3OGE1ODk5YjkwNjY0YyAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVy Q2hyb21pdW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVy UmVuZGVyZXJDaHJvbWl1bS5oCkBAIC02NCw2ICs2NCw3IEBAIHB1YmxpYzoKICAgICAvLyBVcGRh dGVzIHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllciB0aGF0IGZhbGwgaW5zaWRlIHRoZSB1 cGRhdGVSZWN0IGFuZCByZWNvbXBvc2l0ZXMKICAgICAvLyBhbGwgdGhlIGxheWVycy4KICAgICB2 b2lkIGRyYXdMYXllcnMoY29uc3QgSW50UmVjdCYgdXBkYXRlUmVjdCwgY29uc3QgSW50UmVjdCYg dmlzaWJsZVJlY3QsIGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0LCBjb25zdCBJbnRQb2ludCYg c2Nyb2xsUG9zaXRpb24pOworICAgIHZvaWQgcHJlc2VudCgpOyAvLyBQZXJmb3JtIGJ1ZmZlciBz d2FwIHRvIHByZXNlbnQgcmVuZGVyZWQgYnVmZmVyLgogCiAgICAgdm9pZCBzZXRSb290TGF5ZXIo UGFzc1JlZlB0cjxMYXllckNocm9taXVtPiBsYXllcikgeyBtX3Jvb3RMYXllciA9IGxheWVyOyB9 CiAgICAgTGF5ZXJDaHJvbWl1bSogcm9vdExheWVyKCkgeyByZXR1cm4gbV9yb290TGF5ZXIuZ2V0 KCk7IH0KQEAgLTkwLDYgKzkxLDEwIEBAIHB1YmxpYzoKICAgICBjb25zdCBDb250ZW50TGF5ZXJD aHJvbWl1bTo6U2hhcmVkVmFsdWVzKiBjb250ZW50TGF5ZXJTaGFyZWRWYWx1ZXMoKSBjb25zdCB7 IHJldHVybiBtX2NvbnRlbnRMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsgfQogICAgIGNvbnN0IENh bnZhc0xheWVyQ2hyb21pdW06OlNoYXJlZFZhbHVlcyogY2FudmFzTGF5ZXJTaGFyZWRWYWx1ZXMo KSBjb25zdCB7IHJldHVybiBtX2NhbnZhc0xheWVyU2hhcmVkVmFsdWVzLmdldCgpOyB9CiAKKyAg ICBpbnQgcm9vdExheWVyVGV4dHVyZVdpZHRoKCkgY29uc3QgeyByZXR1cm4gbV9yb290TGF5ZXJU ZXh0dXJlV2lkdGg7IH0KKyAgICBpbnQgcm9vdExheWVyVGV4dHVyZUhlaWdodCgpIGNvbnN0IHsg cmV0dXJuIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodDsgfQorICAgIHZvaWQgZ2V0RnJhbWVidWZm ZXJQaXhlbHModm9pZCAqcGl4ZWxzLCBjb25zdCBpbnQgd2lkdGgsIGNvbnN0IGludCBoZWlnaHQp OworCiBwcml2YXRlOgogICAgIHZvaWQgdXBkYXRlTGF5ZXJzUmVjdXJzaXZlKExheWVyQ2hyb21p dW0qIGxheWVyLCBjb25zdCBUcmFuc2Zvcm1hdGlvbk1hdHJpeCYgcGFyZW50TWF0cml4LCBmbG9h dCBvcGFjaXR5KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggNWQ4NjBlZDcxNDQxYzQwMTI0NmQ4ZGZjMTc3 MjNlNWViZTliZmE0MS4uMDM4NWFkZDQ2NjhhZDNlYzFlODkyNjBjOGI3YjBkZmE3ZTQzODZlYSAx MDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTAtMDgtMzAgIFcuIEphbWVzIE1hY0xl YW4gIDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVGh1bWJuYWlscyBub3QgZ2VuZXJhdGVk IGZvciBHUFUgUmVuZGVyZWQgUGFnZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTQ0MTI3CisKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6cGFpbnQpOgorCiAyMDEwLTA4LTI1ICBTYXRp c2ggU2FtcGF0aCAgPHNhdGlzaEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkg SmVyZW15IE9ybG93LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1w bC5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcAppbmRleCAzODNiNzE2 NzMxNGVkYWYzNDJkYWViNDhmM2I1NjYxMGVkNzUzMTQ4Li4xOWUyZWVhMzNhMmRkNzAyZGIyYWQ0 ZThkYTZmN2NmYjg2MTczZDM1IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZp ZXdJbXBsLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcApAQCAt MTE1LDYgKzExNSwxMCBAQAogI2luY2x1ZGUgIldlYlZpZXdDbGllbnQuaCIKICNpbmNsdWRlICJ3 dGYvT3duUHRyLmgiCiAKKyNpZiBQTEFURk9STShDRykKKyNpbmNsdWRlIDxDb3JlR3JhcGhpY3Mv Q0dDb250ZXh0Lmg+CisjZW5kaWYKKwogI2lmIE9TKFdJTkRPV1MpCiAjaW5jbHVkZSAiUmVuZGVy VGhlbWVDaHJvbWl1bVdpbi5oIgogI2Vsc2UKQEAgLTk1NSw2ICs5NTksNyBAQCB2b2lkIFdlYlZp ZXdJbXBsOjpwYWludChXZWJDYW52YXMqIGNhbnZhcywgY29uc3QgV2ViUmVjdCYgcmVjdCkKICAg ICAgICAgICAgIHdlYmZyYW1lLT5wYWludChjYW52YXMsIHJlY3QpOwogI2lmIFVTRShBQ0NFTEVS QVRFRF9DT01QT1NJVElORykKICAgICB9IGVsc2UgeworCiAgICAgICAgIC8vIERyYXcgdGhlIGNv bnRlbnRzIG9mIHRoZSByb290IGxheWVyLgogICAgICAgICB1cGRhdGVSb290TGF5ZXJDb250ZW50 cyhyZWN0KTsKIApAQCAtOTcxLDYgKzk3Niw5NCBAQCB2b2lkIFdlYlZpZXdJbXBsOjpwYWludChX ZWJDYW52YXMqIGNhbnZhcywgY29uc3QgV2ViUmVjdCYgcmVjdCkKIAogICAgICAgICAvLyBBc2sg dGhlIGxheWVyIGNvbXBvc2l0b3IgdG8gcmVkcmF3IGFsbCB0aGUgbGF5ZXJzLgogICAgICAgICBt X2xheWVyUmVuZGVyZXItPmRyYXdMYXllcnMocmVjdCwgdmlzaWJsZVJlY3QsIGNvbnRlbnRSZWN0 LCBJbnRQb2ludCh2aWV3LT5zY3JvbGxYKCksIHZpZXctPnNjcm9sbFkoKSkpOworCisgICAgICAg IC8vIElmIGEgY2FudmFzIHdhcyBwYXNzZWQgaW4sIHdlIHVzZSBpdCB0byBncmFiIGEgY29weSBv ZiB0aGUKKyAgICAgICAgLy8gZnJlc2hseS1yZW5kZXJlZCBwaXhlbHMuCisgICAgICAgIGlmIChj YW52YXMpIHsKKyAgICAgICAgICAgIHZvaWQqIHBpeGVscyA9IDA7CisjaWYgUExBVEZPUk0oU0tJ QSkKKyAgICAgICAgICAgIGNvbnN0IFNrQml0bWFwIGJpdG1hcCA9IGNhbnZhcy0+Z2V0RGV2aWNl KCktPmFjY2Vzc0JpdG1hcChmYWxzZSk7CisgICAgICAgICAgICBpZiAoYml0bWFwLmNvbmZpZygp ID09IFNrQml0bWFwOjprQVJHQl84ODg4X0NvbmZpZykgeworCisgICAgICAgICAgICAgICAgaW50 IHdpZHRoID0gYml0bWFwLndpZHRoKCk7CisgICAgICAgICAgICAgICAgaW50IGhlaWdodCA9IGJp dG1hcC5oZWlnaHQoKTsKKworICAgICAgICAgICAgICAgIFNrQXV0b0xvY2tQaXhlbHMgYml0bWFw TG9jayhiaXRtYXApOworCisgICAgICAgICAgICAgICAgaWYgKG1fbGF5ZXJSZW5kZXJlci0+cm9v dExheWVyVGV4dHVyZVdpZHRoKCkgPT0gd2lkdGgKKyAgICAgICAgICAgICAgICAgICAgJiYgbV9s YXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlSGVpZ2h0KCkgPT0gaGVpZ2h0KSB7CisgICAg ICAgICAgICAgICAgICAgIHBpeGVscyA9IGJpdG1hcC5nZXRQaXhlbHMoKTsKKyAgICAgICAgICAg ICAgICAgICAgbV9sYXllclJlbmRlcmVyLT5nZXRGcmFtZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHdp ZHRoLCBoZWlnaHQpOworICAgICAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAg ICAgIGludCB3aWR0aFJlc2l6ZSA9IG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVdp ZHRoKCk7CisgICAgICAgICAgICAgICAgICAgIGludCBoZWlnaHRSZXNpemUgPSBtX2xheWVyUmVu ZGVyZXItPnJvb3RMYXllclRleHR1cmVIZWlnaHQoKTsKKworICAgICAgICAgICAgICAgICAgICAv LyBDcmVhdGUgdGVtcCBiaXRtYXAgb2YgY29ycmVjdCBzaXplIHRvIGNvcHkgcGl4ZWxzIGludG8u CisgICAgICAgICAgICAgICAgICAgIE93blB0cjxza2lhOjpQbGF0Zm9ybUNhbnZhcz4gY2FudmFz UmVzaXplID0gT3duUHRyPHNraWE6OlBsYXRmb3JtQ2FudmFzPihuZXcgc2tpYTo6UGxhdGZvcm1D YW52YXMoKSk7CisgICAgICAgICAgICAgICAgICAgIGlmIChjYW52YXNSZXNpemUuZ2V0KCkgJiYg Y2FudmFzUmVzaXplLT5pbml0aWFsaXplKHdpZHRoUmVzaXplLCBoZWlnaHRSZXNpemUsIHRydWUp KSB7CisgICAgICAgICAgICAgICAgICAgICAgICBTa0JpdG1hcCBiaXRtYXBSZXNpemUgPSBjYW52 YXNSZXNpemUtPmdldERldmljZSgpLT5hY2Nlc3NCaXRtYXAoZmFsc2UpOworICAgICAgICAgICAg ICAgICAgICAgICAgcGl4ZWxzID0gYml0bWFwUmVzaXplLmdldFBpeGVscygpOworICAgICAgICAg ICAgICAgICAgICAgICAgbV9sYXllclJlbmRlcmVyLT5nZXRGcmFtZWJ1ZmZlclBpeGVscyhwaXhl bHMsIHdpZHRoUmVzaXplLCBoZWlnaHRSZXNpemUpOworICAgICAgICAgICAgICAgICAgICAgICAg U2tJUmVjdCBzcmNSZWN0OworICAgICAgICAgICAgICAgICAgICAgICAgc3JjUmVjdC5zZXQoMCwg MCwgYml0bWFwUmVzaXplLndpZHRoKCksIGJpdG1hcFJlc2l6ZS5oZWlnaHQoKSk7CisgICAgICAg ICAgICAgICAgICAgICAgICBTa1JlY3QgZHN0UmVjdCA9IFNrUmVjdDo6TWFrZVdIKGJpdG1hcC53 aWR0aCgpLCBiaXRtYXAuaGVpZ2h0KCkpOworICAgICAgICAgICAgICAgICAgICAgICAgY2FudmFz LT5kcmF3Qml0bWFwUmVjdChiaXRtYXBSZXNpemUsICZzcmNSZWN0LCBkc3RSZWN0LCAwKTsKKyAg ICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICAgICAgYml0bWFwLmVyYXNlQ29sb3IoU0tfQ29sb3JXSElURSk7Cisg ICAgICAgICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgICAgICB9CisjZWxp ZiBQTEFURk9STShDRykKKyAgICAgICAgICAgIENHQ29udGV4dFJlZiBiaXRtYXAgPSByZWludGVy cHJldF9jYXN0PENHQ29udGV4dFJlZj4oY2FudmFzKTsKKyAgICAgICAgICAgIGlmIChDR0JpdG1h cENvbnRleHRHZXRSb3dCeXRlcyhiaXRtYXApID09IDQgKiB3aWR0aCkgeworCisgICAgICAgICAg ICAgICAgaW50IHdpZHRoID0gQ0dCaXRtYXBDb250ZXh0R2V0V2lkdGgoYml0bWFwKTsKKyAgICAg ICAgICAgICAgICBpbnQgaGVpZ2h0ID0gQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1hcCk7 CisKKyAgICAgICAgICAgICAgICBpZiAobV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJl V2lkdGgoKSA9PSB3aWR0aAorICAgICAgICAgICAgICAgICAgICAmJiBtX2xheWVyUmVuZGVyZXIt PnJvb3RMYXllclRleHR1cmVIZWlnaHQoKSA9PSBoZWlnaHQpIHsKKyAgICAgICAgICAgICAgICAg IHBpeGVscyA9IENHQml0bWFwQ29udGV4dEdldERhdGEoYml0bWFwKTsKKyAgICAgICAgICAgICAg ICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCB3aWR0aCwg aGVpZ2h0KTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBp bnQgd2lkdGhSZXNpemUgPSBtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVXaWR0aCgp OworICAgICAgICAgICAgICAgICAgICBpbnQgaGVpZ2h0UmVzaXplID0gbV9sYXllclJlbmRlcmVy LT5yb290TGF5ZXJUZXh0dXJlSGVpZ2h0KCk7CisKKyAgICAgICAgICAgICAgICAgICAgLy8gQ3Jl YXRlIHRlbXAgYml0bWFwIG9mIHNhbWUgc2l6ZSBhcyByZW5kZXJlZCBsYXllciB0byBjb3B5IHBp eGVscyBpbnRvLgorICAgICAgICAgICAgICAgICAgICBDR0NvbG9yU3BhY2VSZWYgY29sb3JTcGFj ZSA9IENHQ29sb3JTcGFjZUNyZWF0ZURldmljZVJHQigpOworICAgICAgICAgICAgICAgICAgICBD R0NvbnRleHRSZWYgYml0bWFwUmVzaXplID0gQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKDAsIHdpZHRo UmVzaXplLCBoZWlnaHRSZXNpemUsIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDgsIDQgKiB3aWR0aFJlc2l6ZSwg Y29sb3JTcGFjZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZExhc3Qp OworICAgICAgICAgICAgICAgICAgICBpZiAoYml0bWFwUmVzaXplKSB7CisgICAgICAgICAgICAg ICAgICAgICAgcGl4ZWxzID0gQ0dCaXRtYXBDb250ZXh0R2V0RGF0YShiaXRtYXBSZXNpemUpOwor ICAgICAgICAgICAgICAgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhl bHMocGl4ZWxzLCB3aWR0aFJlc2l6ZSwgaGVpZ2h0UmVzaXplKTsKKworICAgICAgICAgICAgICAg ICAgICAgIC8vIENvcHkgYml0bWFwIGJhY2sgdG8gaW5wdXQgYml0bWFwLiBUaGUgaW1hZ2UgaXMg aW52ZXJ0ZWQgYWNjb3JkaW5nIHRvIENHLAorICAgICAgICAgICAgICAgICAgICAgIC8vIHNvIHNl dCB1cCB0aGUgYXBwcm9wcmlhdGUgdHJhbnNmb3JtIHRvIGludmVydCB2ZXJ0aWNhbCBheGlzIGFu ZCBtb3ZlIG9yaWdpbgorICAgICAgICAgICAgICAgICAgICAgIC8vIHRvIGJvdHRvbSBsZWZ0Lgor ICAgICAgICAgICAgICAgICAgICAgIENHQ29udGV4dFNhdmVHU3RhdGUoYml0bWFwKTsKKyAgICAg ICAgICAgICAgICAgICAgICBDR0NvbnRleHRUcmFuc2xhdGVDVE0oYml0bWFwLCAwLCBDR0JpdG1h cENvbnRleHRHZXRIZWlnaHQoYml0bWFwKSk7CisgICAgICAgICAgICAgICAgICAgICAgQ0dDb250 ZXh0U2NhbGVDVE0oYml0bWFwLCAxLjAsIC0xLjApOworICAgICAgICAgICAgICAgICAgICAgIENH Q29udGV4dERyYXdJbWFnZShiaXRtYXAsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIENHUmVjdE1ha2UoMCwgMCwgQ0dCaXRtYXBDb250ZXh0R2V0V2lkdGgoYml0bWFw KSwgQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1hcCkpLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBDR0JpdG1hcENvbnRleHRDcmVhdGVJbWFnZShiaXRtYXBS ZXNpemUpKTsKKyAgICAgICAgICAgICAgICAgICAgICBDR0NvbnRleHRSZXN0b3JlR1N0YXRlKGJp dG1hcCk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICB9CisgICAgICAg ICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIENHQ29udGV4dFNhdmVHU3RhdGUoYml0bWFw KTsKKyAgICAgICAgICAgICAgICBDR0NvbnRleHRTZXRSR0JGaWxsQ29sb3IoYml0bWFwLCAxLjAs IDEuMCwgMS4wLCAxLjApOworICAgICAgICAgICAgICAgIENHQ29udGV4dEZpbGxSZWN0KGJpdG1h cCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDR1JlY3RNYWtlKDAsIDAsIENH Qml0bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcCksIENHQml0bWFwQ29udGV4dEdldEhlaWdodChi aXRtYXApKSk7CisgICAgICAgICAgICAgICAgQ0dDb250ZXh0UmVzdG9yZUdTdGF0ZShiaXRtYXAp OworICAgICAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgfQor I2Vsc2UKKyNlcnJvciBNdXN0IHBvcnQgdG8geW91ciBwbGF0Zm9ybS4KKyNlbmRpZgorICAgICAg ICB9CisKKyAgICAgICAgbV9sYXllclJlbmRlcmVyLT5wcmVzZW50KCk7IC8vIERvIGZpbmFsIGRp c3BsYXkgYnkgc3dhcHBpbmcgYnVmZmVycy4KICAgICB9CiAjZW5kaWYKIH0K 65945 2010-08-30 13:00:04 -0700 2010-08-31 05:52:44 -0700 Patch bug-44127-20100830160025.patch text/plain 11131 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZWI1OTEwZWRhOWE0MGJmOTkwNDQ2Yzc0MWQzZDFhMjViMTYyMWFlNy4uYjE3YThlNGMyNmRkMjA3 Y2MwN2I2MTVjZGIzNzNmZmRmZmVlYzFmNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wOC0zMCAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKworICAgICAgICBBZGRz IHBpeGVsLXJlYWRiYWNrIGZvciBHUFUgY29tcG9zaXRlZCBwYWdlcyB0byBhbGxvdyBmb3IgdGh1 bWJuYWlsaW5nLAorICAgICAgICBwcmludGluZyBhbmQgb3RoZXIgc2VydmljZXMgdG8gd29yayB3 aXRoIEdQVSByZW5kZXJlZCBwYWdlcy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXll clJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpwcmVzZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVy ZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29y ZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlV2lkdGgpOgorICAgICAg ICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlSGVpZ2h0 KToKKwogMjAxMC0wOC0yNSAgSWx5YSBUaWtob25vdnNreSAgPGxvaXNsb0BjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWXVyeSBTZW1pa2hhdHNreS4KZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNw cCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9t aXVtLmNwcAppbmRleCBjZjIzODcxOGIyMWJiNDBiYjY5NzY2MjdkOWYyMzM4NTRlNDQ2OWZiLi41 Y2IxZWI3NmVkM2RmYzMzYmEyODAwNTBjZmY5ZGU0OGFiMTFkMTViIDEwMDY0NAotLS0gYS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAK KysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hy b21pdW0uY3BwCkBAIC0zMTAsMTEgKzMxMCw0MiBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1 bTo6ZHJhd0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0Jgog CiAgICAgR0xDKGdsRGlzYWJsZShHTF9TQ0lTU09SX1RFU1QpKTsKIAorICAgIGdsRmx1c2goKTsK K30KKwordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnByZXNlbnQoKQorewogICAgIG1fZ2xl czJDb250ZXh0LT5zd2FwQnVmZmVycygpOwogCiAgICAgbV9uZWVkc0Rpc3BsYXkgPSBmYWxzZTsK IH0KIAordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKHZv aWQgKnBpeGVscywgY29uc3QgaW50IHdpZHRoLCBjb25zdCBpbnQgaGVpZ2h0KQoreworICAgIEFT U0VSVCh3aWR0aCA9PSBtX3Jvb3RMYXllclRleHR1cmVXaWR0aCAmJiBoZWlnaHQgPT0gbV9yb290 TGF5ZXJUZXh0dXJlSGVpZ2h0KTsKKworICAgIGlmICghcGl4ZWxzKQorICAgICAgICByZXR1cm47 CisKKyAgICBtYWtlQ29udGV4dEN1cnJlbnQoKTsKKworICAgIEdMQyhnbFJlYWRQaXhlbHMoMCwg MCwgd2lkdGgsIGhlaWdodCwKKyAgICAgICAgICAgICAgICAgICAgIEdMX1JHQkEsIEdMX1VOU0lH TkVEX0JZVEUsIHBpeGVscykpOworCisgICAgLy8gRmxpcCBwaXhlbHMgdmVydGljYWxseS4KKyAg ICBjb25zdCBpbnQgcm93Qnl0ZXMgPSA0ICogd2lkdGg7CisgICAgT3duUHRyPHVuc2lnbmVkIGNo YXI+IGxpbmVUZW1wKG5ldyB1bnNpZ25lZCBjaGFyW3Jvd0J5dGVzXSk7CisgICAgZm9yIChpbnQg cm93MSA9IDAsIHJvdzIgPSBoZWlnaHQgLSAxOyByb3cxIDwgaGVpZ2h0IC8gMjsgKytyb3cxLCAt LXJvdzIpIHsKKworICAgICAgICB1bnNpZ25lZCBjaGFyKiBwdHIxID0gc3RhdGljX2Nhc3Q8dW5z aWduZWQgY2hhcio+KHBpeGVscykgKyByb3cxICogcm93Qnl0ZXM7CisgICAgICAgIHVuc2lnbmVk IGNoYXIqIHB0cjIgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4ocGl4ZWxzKSArIHJvdzIg KiByb3dCeXRlczsKKworICAgICAgICBtZW1jcHkobGluZVRlbXAuZ2V0KCksIHB0cjEsIHJvd0J5 dGVzKTsKKyAgICAgICAgbWVtY3B5KHB0cjEsIHB0cjIsIHJvd0J5dGVzKTsKKyAgICAgICAgbWVt Y3B5KHB0cjIsIGxpbmVUZW1wLmdldCgpLCByb3dCeXRlcyk7CisgICAgfQorfQorCiAvLyBGSVhN RTogVGhpcyBtZXRob2Qgc2hvdWxkIGV2ZW50dWFsbHkgYmUgcmVwbGFjZWQgYnkgYSBwcm9wZXIg dGV4dHVyZSBtYW5hZ2VyLgogdW5zaWduZWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpjcmVhdGVM YXllclRleHR1cmUoKQogewpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggMjRiYmU2NTI4MjhjMWY5 OGE1MzFlMjEyOGY2OTE4ZDFlOWU4YzM2My4uNjVkMzdiODdkZTVkYjAwM2NjZjM4MWVhNDA3OGE1 ODk5YjkwNjY0YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC02NCw2ICs2NCw3IEBAIHB1Ymxp YzoKICAgICAvLyBVcGRhdGVzIHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllciB0aGF0IGZh bGwgaW5zaWRlIHRoZSB1cGRhdGVSZWN0IGFuZCByZWNvbXBvc2l0ZXMKICAgICAvLyBhbGwgdGhl IGxheWVycy4KICAgICB2b2lkIGRyYXdMYXllcnMoY29uc3QgSW50UmVjdCYgdXBkYXRlUmVjdCwg Y29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0LCBj b25zdCBJbnRQb2ludCYgc2Nyb2xsUG9zaXRpb24pOworICAgIHZvaWQgcHJlc2VudCgpOyAvLyBQ ZXJmb3JtIGJ1ZmZlciBzd2FwIHRvIHByZXNlbnQgcmVuZGVyZWQgYnVmZmVyLgogCiAgICAgdm9p ZCBzZXRSb290TGF5ZXIoUGFzc1JlZlB0cjxMYXllckNocm9taXVtPiBsYXllcikgeyBtX3Jvb3RM YXllciA9IGxheWVyOyB9CiAgICAgTGF5ZXJDaHJvbWl1bSogcm9vdExheWVyKCkgeyByZXR1cm4g bV9yb290TGF5ZXIuZ2V0KCk7IH0KQEAgLTkwLDYgKzkxLDEwIEBAIHB1YmxpYzoKICAgICBjb25z dCBDb250ZW50TGF5ZXJDaHJvbWl1bTo6U2hhcmVkVmFsdWVzKiBjb250ZW50TGF5ZXJTaGFyZWRW YWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NvbnRlbnRMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsg fQogICAgIGNvbnN0IENhbnZhc0xheWVyQ2hyb21pdW06OlNoYXJlZFZhbHVlcyogY2FudmFzTGF5 ZXJTaGFyZWRWYWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NhbnZhc0xheWVyU2hhcmVkVmFsdWVz LmdldCgpOyB9CiAKKyAgICBpbnQgcm9vdExheWVyVGV4dHVyZVdpZHRoKCkgY29uc3QgeyByZXR1 cm4gbV9yb290TGF5ZXJUZXh0dXJlV2lkdGg7IH0KKyAgICBpbnQgcm9vdExheWVyVGV4dHVyZUhl aWdodCgpIGNvbnN0IHsgcmV0dXJuIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodDsgfQorICAgIHZv aWQgZ2V0RnJhbWVidWZmZXJQaXhlbHModm9pZCAqcGl4ZWxzLCBjb25zdCBpbnQgd2lkdGgsIGNv bnN0IGludCBoZWlnaHQpOworCiBwcml2YXRlOgogICAgIHZvaWQgdXBkYXRlTGF5ZXJzUmVjdXJz aXZlKExheWVyQ2hyb21pdW0qIGxheWVyLCBjb25zdCBUcmFuc2Zvcm1hdGlvbk1hdHJpeCYgcGFy ZW50TWF0cml4LCBmbG9hdCBvcGFjaXR5KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggNWQ4NjBlZDcxNDQx YzQwMTI0NmQ4ZGZjMTc3MjNlNWViZTliZmE0MS4uZDhiMjYyZjAzMzVkNzkwZjI3MWFhMGQ4ODg5 ZDk1NzQ0ZmZmMWFlNyAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysg Yi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTAtMDgtMzAg IFcuIEphbWVzIE1hY0xlYW4gIDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVGh1bWJuYWls cyBub3QgZ2VuZXJhdGVkIGZvciBHUFUgUmVuZGVyZWQgUGFnZXMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0MTI3CisKKyAgICAgICAgTW9kaWZpZWQg V2ViVmlld0ltcGw6OnBhaW50KCkgdG8gZGV0ZWN0IG5vbi1udWxsIGNhbnZhcyBwb2ludGVycyB3 aGVuCisgICAgICAgIGFjY2VsZXJhdGVkIGNvbXBvc2l0aW5nIGlzIGFjdGl2ZSwgYW5kIGluc3Rl YWQgZmlsbHMgdGhlIHBpeGVsIGJ1ZmZlcgorICAgICAgICBmcm9tIHRoZSBHUFUgZnJhbWVidWZm ZXIuIEluY2x1ZGVzIHJlLXNjYWxpbmcgc3VwcG9ydCB3aGVuIHByb3ZpZGVkCisgICAgICAgIGNh bnZhcyBkb2VzIG5vdCBtYXRjaCBzaXplIG9mIGN1cnJlbnQgcmVuZGVyIGxheWVyLgorCisgICAg ICAgICogc3JjL1dlYlZpZXdJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6 OnBhaW50KToKKwogMjAxMC0wOC0yNSAgU2F0aXNoIFNhbXBhdGggIDxzYXRpc2hAY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEplcmVteSBPcmxvdy4KZGlmZiAtLWdpdCBhL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJWaWV3SW1wbC5jcHAKaW5kZXggMzgzYjcxNjczMTRlZGFmMzQyZGFlYjQ4ZjNiNTY2MTBlZDc1 MzE0OC4uMTllMmVlYTMzYTJkZDcwMmRiMmFkNGU4ZGE2ZjdjZmI4NjE3M2QzNSAxMDA2NDQKLS0t IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTExNSw2ICsxMTUsMTAgQEAKICNpbmNsdWRlICJX ZWJWaWV3Q2xpZW50LmgiCiAjaW5jbHVkZSAid3RmL093blB0ci5oIgogCisjaWYgUExBVEZPUk0o Q0cpCisjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NHQ29udGV4dC5oPgorI2VuZGlmCisKICNpZiBP UyhXSU5ET1dTKQogI2luY2x1ZGUgIlJlbmRlclRoZW1lQ2hyb21pdW1XaW4uaCIKICNlbHNlCkBA IC05NTUsNiArOTU5LDcgQEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52 YXMsIGNvbnN0IFdlYlJlY3QmIHJlY3QpCiAgICAgICAgICAgICB3ZWJmcmFtZS0+cGFpbnQoY2Fu dmFzLCByZWN0KTsKICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCiAgICAgfSBlbHNl IHsKKwogICAgICAgICAvLyBEcmF3IHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllci4KICAg ICAgICAgdXBkYXRlUm9vdExheWVyQ29udGVudHMocmVjdCk7CiAKQEAgLTk3MSw2ICs5NzYsOTQg QEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdlYlJl Y3QmIHJlY3QpCiAKICAgICAgICAgLy8gQXNrIHRoZSBsYXllciBjb21wb3NpdG9yIHRvIHJlZHJh dyBhbGwgdGhlIGxheWVycy4KICAgICAgICAgbV9sYXllclJlbmRlcmVyLT5kcmF3TGF5ZXJzKHJl Y3QsIHZpc2libGVSZWN0LCBjb250ZW50UmVjdCwgSW50UG9pbnQodmlldy0+c2Nyb2xsWCgpLCB2 aWV3LT5zY3JvbGxZKCkpKTsKKworICAgICAgICAvLyBJZiBhIGNhbnZhcyB3YXMgcGFzc2VkIGlu LCB3ZSB1c2UgaXQgdG8gZ3JhYiBhIGNvcHkgb2YgdGhlCisgICAgICAgIC8vIGZyZXNobHktcmVu ZGVyZWQgcGl4ZWxzLgorICAgICAgICBpZiAoY2FudmFzKSB7CisgICAgICAgICAgICB2b2lkKiBw aXhlbHMgPSAwOworI2lmIFBMQVRGT1JNKFNLSUEpCisgICAgICAgICAgICBjb25zdCBTa0JpdG1h cCBiaXRtYXAgPSBjYW52YXMtPmdldERldmljZSgpLT5hY2Nlc3NCaXRtYXAoZmFsc2UpOworICAg ICAgICAgICAgaWYgKGJpdG1hcC5jb25maWcoKSA9PSBTa0JpdG1hcDo6a0FSR0JfODg4OF9Db25m aWcpIHsKKworICAgICAgICAgICAgICAgIGludCB3aWR0aCA9IGJpdG1hcC53aWR0aCgpOworICAg ICAgICAgICAgICAgIGludCBoZWlnaHQgPSBiaXRtYXAuaGVpZ2h0KCk7CisKKyAgICAgICAgICAg ICAgICBTa0F1dG9Mb2NrUGl4ZWxzIGJpdG1hcExvY2soYml0bWFwKTsKKworICAgICAgICAgICAg ICAgIGlmIChtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVXaWR0aCgpID09IHdpZHRo CisgICAgICAgICAgICAgICAgICAgICYmIG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVy ZUhlaWdodCgpID09IGhlaWdodCkgeworICAgICAgICAgICAgICAgICAgICBwaXhlbHMgPSBiaXRt YXAuZ2V0UGl4ZWxzKCk7CisgICAgICAgICAgICAgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0 RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCB3aWR0aCwgaGVpZ2h0KTsKKyAgICAgICAgICAgICAg ICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpbnQgd2lkdGhSZXNpemUgPSBtX2xheWVy UmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVXaWR0aCgpOworICAgICAgICAgICAgICAgICAgICBp bnQgaGVpZ2h0UmVzaXplID0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlSGVpZ2h0 KCk7CisKKyAgICAgICAgICAgICAgICAgICAgLy8gQ3JlYXRlIHRlbXAgYml0bWFwIG9mIGNvcnJl Y3Qgc2l6ZSB0byBjb3B5IHBpeGVscyBpbnRvLgorICAgICAgICAgICAgICAgICAgICBPd25QdHI8 c2tpYTo6UGxhdGZvcm1DYW52YXM+IGNhbnZhc1Jlc2l6ZSA9IE93blB0cjxza2lhOjpQbGF0Zm9y bUNhbnZhcz4obmV3IHNraWE6OlBsYXRmb3JtQ2FudmFzKCkpOworICAgICAgICAgICAgICAgICAg ICBpZiAoY2FudmFzUmVzaXplLmdldCgpICYmIGNhbnZhc1Jlc2l6ZS0+aW5pdGlhbGl6ZSh3aWR0 aFJlc2l6ZSwgaGVpZ2h0UmVzaXplLCB0cnVlKSkgeworICAgICAgICAgICAgICAgICAgICAgICAg U2tCaXRtYXAgYml0bWFwUmVzaXplID0gY2FudmFzUmVzaXplLT5nZXREZXZpY2UoKS0+YWNjZXNz Qml0bWFwKGZhbHNlKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHBpeGVscyA9IGJpdG1hcFJl c2l6ZS5nZXRQaXhlbHMoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIG1fbGF5ZXJSZW5kZXJl ci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCB3aWR0aFJlc2l6ZSwgaGVpZ2h0UmVzaXpl KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIFNrSVJlY3Qgc3JjUmVjdDsKKyAgICAgICAgICAg ICAgICAgICAgICAgIHNyY1JlY3Quc2V0KDAsIDAsIGJpdG1hcFJlc2l6ZS53aWR0aCgpLCBiaXRt YXBSZXNpemUuaGVpZ2h0KCkpOworICAgICAgICAgICAgICAgICAgICAgICAgU2tSZWN0IGRzdFJl Y3QgPSBTa1JlY3Q6Ok1ha2VXSChiaXRtYXAud2lkdGgoKSwgYml0bWFwLmhlaWdodCgpKTsKKyAg ICAgICAgICAgICAgICAgICAgICAgIGNhbnZhcy0+ZHJhd0JpdG1hcFJlY3QoYml0bWFwUmVzaXpl LCAmc3JjUmVjdCwgZHN0UmVjdCwgMCk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIGJpdG1hcC5l cmFzZUNvbG9yKFNLX0NvbG9yV0hJVEUpOworICAgICAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVB Q0hFRCgpOworICAgICAgICAgICAgfQorI2VsaWYgUExBVEZPUk0oQ0cpCisgICAgICAgICAgICBD R0NvbnRleHRSZWYgYml0bWFwID0gcmVpbnRlcnByZXRfY2FzdDxDR0NvbnRleHRSZWY+KGNhbnZh cyk7CisgICAgICAgICAgICBpZiAoQ0dCaXRtYXBDb250ZXh0R2V0Um93Qnl0ZXMoYml0bWFwKSA9 PSA0ICogd2lkdGgpIHsKKworICAgICAgICAgICAgICAgIGludCB3aWR0aCA9IENHQml0bWFwQ29u dGV4dEdldFdpZHRoKGJpdG1hcCk7CisgICAgICAgICAgICAgICAgaW50IGhlaWdodCA9IENHQml0 bWFwQ29udGV4dEdldEhlaWdodChiaXRtYXApOworCisgICAgICAgICAgICAgICAgaWYgKG1fbGF5 ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVdpZHRoKCkgPT0gd2lkdGgKKyAgICAgICAgICAg ICAgICAgICAgJiYgbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlSGVpZ2h0KCkgPT0g aGVpZ2h0KSB7CisgICAgICAgICAgICAgICAgICBwaXhlbHMgPSBDR0JpdG1hcENvbnRleHRHZXRE YXRhKGJpdG1hcCk7CisgICAgICAgICAgICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdldEZyYW1l YnVmZmVyUGl4ZWxzKHBpeGVscywgd2lkdGgsIGhlaWdodCk7CisgICAgICAgICAgICAgICAgfSBl bHNlIHsKKyAgICAgICAgICAgICAgICAgICAgaW50IHdpZHRoUmVzaXplID0gbV9sYXllclJlbmRl cmVyLT5yb290TGF5ZXJUZXh0dXJlV2lkdGgoKTsKKyAgICAgICAgICAgICAgICAgICAgaW50IGhl aWdodFJlc2l6ZSA9IG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZUhlaWdodCgpOwor CisgICAgICAgICAgICAgICAgICAgIC8vIENyZWF0ZSB0ZW1wIGJpdG1hcCBvZiBzYW1lIHNpemUg YXMgcmVuZGVyZWQgbGF5ZXIgdG8gY29weSBwaXhlbHMgaW50by4KKyAgICAgICAgICAgICAgICAg ICAgQ0dDb2xvclNwYWNlUmVmIGNvbG9yU3BhY2UgPSBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VS R0IoKTsKKyAgICAgICAgICAgICAgICAgICAgQ0dDb250ZXh0UmVmIGJpdG1hcFJlc2l6ZSA9IENH Qml0bWFwQ29udGV4dENyZWF0ZSgwLCB3aWR0aFJlc2l6ZSwgaGVpZ2h0UmVzaXplLCAKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICA4LCA0ICogd2lkdGhSZXNpemUsIGNvbG9yU3BhY2UsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAga0NH SW1hZ2VBbHBoYVByZW11bHRpcGxpZWRMYXN0KTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKGJp dG1hcFJlc2l6ZSkgeworICAgICAgICAgICAgICAgICAgICAgIHBpeGVscyA9IENHQml0bWFwQ29u dGV4dEdldERhdGEoYml0bWFwUmVzaXplKTsKKyAgICAgICAgICAgICAgICAgICAgICBtX2xheWVy UmVuZGVyZXItPmdldEZyYW1lYnVmZmVyUGl4ZWxzKHBpeGVscywgd2lkdGhSZXNpemUsIGhlaWdo dFJlc2l6ZSk7CisKKyAgICAgICAgICAgICAgICAgICAgICAvLyBDb3B5IGJpdG1hcCBiYWNrIHRv IGlucHV0IGJpdG1hcC4gVGhlIGltYWdlIGlzIGludmVydGVkIGFjY29yZGluZyB0byBDRywKKyAg ICAgICAgICAgICAgICAgICAgICAvLyBzbyBzZXQgdXAgdGhlIGFwcHJvcHJpYXRlIHRyYW5zZm9y bSB0byBpbnZlcnQgdmVydGljYWwgYXhpcyBhbmQgbW92ZSBvcmlnaW4KKyAgICAgICAgICAgICAg ICAgICAgICAvLyB0byBib3R0b20gbGVmdC4KKyAgICAgICAgICAgICAgICAgICAgICBDR0NvbnRl eHRTYXZlR1N0YXRlKGJpdG1hcCk7CisgICAgICAgICAgICAgICAgICAgICAgQ0dDb250ZXh0VHJh bnNsYXRlQ1RNKGJpdG1hcCwgMCwgQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1hcCkpOwor ICAgICAgICAgICAgICAgICAgICAgIENHQ29udGV4dFNjYWxlQ1RNKGJpdG1hcCwgMS4wLCAtMS4w KTsKKyAgICAgICAgICAgICAgICAgICAgICBDR0NvbnRleHREcmF3SW1hZ2UoYml0bWFwLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDR1JlY3RNYWtlKDAsIDAsIENH Qml0bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcCksIENHQml0bWFwQ29udGV4dEdldEhlaWdodChi aXRtYXApKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ0dCaXRt YXBDb250ZXh0Q3JlYXRlSW1hZ2UoYml0bWFwUmVzaXplKSk7CisgICAgICAgICAgICAgICAgICAg ICAgQ0dDb250ZXh0UmVzdG9yZUdTdGF0ZShiaXRtYXApOworICAgICAgICAgICAgICAgICAgICB9 CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAg ICBDR0NvbnRleHRTYXZlR1N0YXRlKGJpdG1hcCk7CisgICAgICAgICAgICAgICAgQ0dDb250ZXh0 U2V0UkdCRmlsbENvbG9yKGJpdG1hcCwgMS4wLCAxLjAsIDEuMCwgMS4wKTsKKyAgICAgICAgICAg ICAgICBDR0NvbnRleHRGaWxsUmVjdChiaXRtYXAsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgQ0dSZWN0TWFrZSgwLCAwLCBDR0JpdG1hcENvbnRleHRHZXRXaWR0aChiaXRtYXAp LCBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQoYml0bWFwKSkpOworICAgICAgICAgICAgICAgIENH Q29udGV4dFJlc3RvcmVHU3RhdGUoYml0bWFwKTsKKyAgICAgICAgICAgICAgICBBU1NFUlRfTk9U X1JFQUNIRUQoKTsKKyAgICAgICAgICAgIH0KKyNlbHNlCisjZXJyb3IgTXVzdCBwb3J0IHRvIHlv dXIgcGxhdGZvcm0uCisjZW5kaWYKKyAgICAgICAgfQorCisgICAgICAgIG1fbGF5ZXJSZW5kZXJl ci0+cHJlc2VudCgpOyAvLyBEbyBmaW5hbCBkaXNwbGF5IGJ5IHN3YXBwaW5nIGJ1ZmZlcnMuCiAg ICAgfQogI2VuZGlmCiB9Cg== 66041 2010-08-31 05:52:49 -0700 2010-09-02 13:04:53 -0700 Patch bug-44127-20100831085313.patch text/plain 10980 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZWI1OTEwZWRhOWE0MGJmOTkwNDQ2Yzc0MWQzZDFhMjViMTYyMWFlNy4uYjE3YThlNGMyNmRkMjA3 Y2MwN2I2MTVjZGIzNzNmZmRmZmVlYzFmNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wOC0zMCAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKworICAgICAgICBBZGRz IHBpeGVsLXJlYWRiYWNrIGZvciBHUFUgY29tcG9zaXRlZCBwYWdlcyB0byBhbGxvdyBmb3IgdGh1 bWJuYWlsaW5nLAorICAgICAgICBwcmludGluZyBhbmQgb3RoZXIgc2VydmljZXMgdG8gd29yayB3 aXRoIEdQVSByZW5kZXJlZCBwYWdlcy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXll clJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpwcmVzZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVy ZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29y ZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlV2lkdGgpOgorICAgICAg ICAoV2ViQ29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlSGVpZ2h0 KToKKwogMjAxMC0wOC0yNSAgSWx5YSBUaWtob25vdnNreSAgPGxvaXNsb0BjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWXVyeSBTZW1pa2hhdHNreS4KZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNw cCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9t aXVtLmNwcAppbmRleCBjZjIzODcxOGIyMWJiNDBiYjY5NzY2MjdkOWYyMzM4NTRlNDQ2OWZiLi41 Y2IxZWI3NmVkM2RmYzMzYmEyODAwNTBjZmY5ZGU0OGFiMTFkMTViIDEwMDY0NAotLS0gYS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAK KysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hy b21pdW0uY3BwCkBAIC0zMTAsMTEgKzMxMCw0MiBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1 bTo6ZHJhd0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0Jgog CiAgICAgR0xDKGdsRGlzYWJsZShHTF9TQ0lTU09SX1RFU1QpKTsKIAorICAgIGdsRmx1c2goKTsK K30KKwordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OnByZXNlbnQoKQorewogICAgIG1fZ2xl czJDb250ZXh0LT5zd2FwQnVmZmVycygpOwogCiAgICAgbV9uZWVkc0Rpc3BsYXkgPSBmYWxzZTsK IH0KIAordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKHZv aWQgKnBpeGVscywgY29uc3QgaW50IHdpZHRoLCBjb25zdCBpbnQgaGVpZ2h0KQoreworICAgIEFT U0VSVCh3aWR0aCA9PSBtX3Jvb3RMYXllclRleHR1cmVXaWR0aCAmJiBoZWlnaHQgPT0gbV9yb290 TGF5ZXJUZXh0dXJlSGVpZ2h0KTsKKworICAgIGlmICghcGl4ZWxzKQorICAgICAgICByZXR1cm47 CisKKyAgICBtYWtlQ29udGV4dEN1cnJlbnQoKTsKKworICAgIEdMQyhnbFJlYWRQaXhlbHMoMCwg MCwgd2lkdGgsIGhlaWdodCwKKyAgICAgICAgICAgICAgICAgICAgIEdMX1JHQkEsIEdMX1VOU0lH TkVEX0JZVEUsIHBpeGVscykpOworCisgICAgLy8gRmxpcCBwaXhlbHMgdmVydGljYWxseS4KKyAg ICBjb25zdCBpbnQgcm93Qnl0ZXMgPSA0ICogd2lkdGg7CisgICAgT3duUHRyPHVuc2lnbmVkIGNo YXI+IGxpbmVUZW1wKG5ldyB1bnNpZ25lZCBjaGFyW3Jvd0J5dGVzXSk7CisgICAgZm9yIChpbnQg cm93MSA9IDAsIHJvdzIgPSBoZWlnaHQgLSAxOyByb3cxIDwgaGVpZ2h0IC8gMjsgKytyb3cxLCAt LXJvdzIpIHsKKworICAgICAgICB1bnNpZ25lZCBjaGFyKiBwdHIxID0gc3RhdGljX2Nhc3Q8dW5z aWduZWQgY2hhcio+KHBpeGVscykgKyByb3cxICogcm93Qnl0ZXM7CisgICAgICAgIHVuc2lnbmVk IGNoYXIqIHB0cjIgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4ocGl4ZWxzKSArIHJvdzIg KiByb3dCeXRlczsKKworICAgICAgICBtZW1jcHkobGluZVRlbXAuZ2V0KCksIHB0cjEsIHJvd0J5 dGVzKTsKKyAgICAgICAgbWVtY3B5KHB0cjEsIHB0cjIsIHJvd0J5dGVzKTsKKyAgICAgICAgbWVt Y3B5KHB0cjIsIGxpbmVUZW1wLmdldCgpLCByb3dCeXRlcyk7CisgICAgfQorfQorCiAvLyBGSVhN RTogVGhpcyBtZXRob2Qgc2hvdWxkIGV2ZW50dWFsbHkgYmUgcmVwbGFjZWQgYnkgYSBwcm9wZXIg dGV4dHVyZSBtYW5hZ2VyLgogdW5zaWduZWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpjcmVhdGVM YXllclRleHR1cmUoKQogewpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggMjRiYmU2NTI4MjhjMWY5 OGE1MzFlMjEyOGY2OTE4ZDFlOWU4YzM2My4uNjVkMzdiODdkZTVkYjAwM2NjZjM4MWVhNDA3OGE1 ODk5YjkwNjY0YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC02NCw2ICs2NCw3IEBAIHB1Ymxp YzoKICAgICAvLyBVcGRhdGVzIHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllciB0aGF0IGZh bGwgaW5zaWRlIHRoZSB1cGRhdGVSZWN0IGFuZCByZWNvbXBvc2l0ZXMKICAgICAvLyBhbGwgdGhl IGxheWVycy4KICAgICB2b2lkIGRyYXdMYXllcnMoY29uc3QgSW50UmVjdCYgdXBkYXRlUmVjdCwg Y29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0LCBj b25zdCBJbnRQb2ludCYgc2Nyb2xsUG9zaXRpb24pOworICAgIHZvaWQgcHJlc2VudCgpOyAvLyBQ ZXJmb3JtIGJ1ZmZlciBzd2FwIHRvIHByZXNlbnQgcmVuZGVyZWQgYnVmZmVyLgogCiAgICAgdm9p ZCBzZXRSb290TGF5ZXIoUGFzc1JlZlB0cjxMYXllckNocm9taXVtPiBsYXllcikgeyBtX3Jvb3RM YXllciA9IGxheWVyOyB9CiAgICAgTGF5ZXJDaHJvbWl1bSogcm9vdExheWVyKCkgeyByZXR1cm4g bV9yb290TGF5ZXIuZ2V0KCk7IH0KQEAgLTkwLDYgKzkxLDEwIEBAIHB1YmxpYzoKICAgICBjb25z dCBDb250ZW50TGF5ZXJDaHJvbWl1bTo6U2hhcmVkVmFsdWVzKiBjb250ZW50TGF5ZXJTaGFyZWRW YWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NvbnRlbnRMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsg fQogICAgIGNvbnN0IENhbnZhc0xheWVyQ2hyb21pdW06OlNoYXJlZFZhbHVlcyogY2FudmFzTGF5 ZXJTaGFyZWRWYWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NhbnZhc0xheWVyU2hhcmVkVmFsdWVz LmdldCgpOyB9CiAKKyAgICBpbnQgcm9vdExheWVyVGV4dHVyZVdpZHRoKCkgY29uc3QgeyByZXR1 cm4gbV9yb290TGF5ZXJUZXh0dXJlV2lkdGg7IH0KKyAgICBpbnQgcm9vdExheWVyVGV4dHVyZUhl aWdodCgpIGNvbnN0IHsgcmV0dXJuIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodDsgfQorICAgIHZv aWQgZ2V0RnJhbWVidWZmZXJQaXhlbHModm9pZCAqcGl4ZWxzLCBjb25zdCBpbnQgd2lkdGgsIGNv bnN0IGludCBoZWlnaHQpOworCiBwcml2YXRlOgogICAgIHZvaWQgdXBkYXRlTGF5ZXJzUmVjdXJz aXZlKExheWVyQ2hyb21pdW0qIGxheWVyLCBjb25zdCBUcmFuc2Zvcm1hdGlvbk1hdHJpeCYgcGFy ZW50TWF0cml4LCBmbG9hdCBvcGFjaXR5KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggNWQ4NjBlZDcxNDQx YzQwMTI0NmQ4ZGZjMTc3MjNlNWViZTliZmE0MS4uZDhiMjYyZjAzMzVkNzkwZjI3MWFhMGQ4ODg5 ZDk1NzQ0ZmZmMWFlNyAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysg Yi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTAtMDgtMzAg IFcuIEphbWVzIE1hY0xlYW4gIDx3am1hY2xlYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVGh1bWJuYWls cyBub3QgZ2VuZXJhdGVkIGZvciBHUFUgUmVuZGVyZWQgUGFnZXMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0MTI3CisKKyAgICAgICAgTW9kaWZpZWQg V2ViVmlld0ltcGw6OnBhaW50KCkgdG8gZGV0ZWN0IG5vbi1udWxsIGNhbnZhcyBwb2ludGVycyB3 aGVuCisgICAgICAgIGFjY2VsZXJhdGVkIGNvbXBvc2l0aW5nIGlzIGFjdGl2ZSwgYW5kIGluc3Rl YWQgZmlsbHMgdGhlIHBpeGVsIGJ1ZmZlcgorICAgICAgICBmcm9tIHRoZSBHUFUgZnJhbWVidWZm ZXIuIEluY2x1ZGVzIHJlLXNjYWxpbmcgc3VwcG9ydCB3aGVuIHByb3ZpZGVkCisgICAgICAgIGNh bnZhcyBkb2VzIG5vdCBtYXRjaCBzaXplIG9mIGN1cnJlbnQgcmVuZGVyIGxheWVyLgorCisgICAg ICAgICogc3JjL1dlYlZpZXdJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6 OnBhaW50KToKKwogMjAxMC0wOC0yNSAgU2F0aXNoIFNhbXBhdGggIDxzYXRpc2hAY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEplcmVteSBPcmxvdy4KZGlmZiAtLWdpdCBhL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJWaWV3SW1wbC5jcHAKaW5kZXggMzgzYjcxNjczMTRlZGFmMzQyZGFlYjQ4ZjNiNTY2MTBlZDc1 MzE0OC4uNjA4MzQxMGVlMjYwMjZkM2VhZTBlM2Q1Y2E2NzNiMDdhM2Y4ZmRiNSAxMDA2NDQKLS0t IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTExNSw2ICsxMTUsMTAgQEAKICNpbmNsdWRlICJX ZWJWaWV3Q2xpZW50LmgiCiAjaW5jbHVkZSAid3RmL093blB0ci5oIgogCisjaWYgUExBVEZPUk0o Q0cpCisjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NHQ29udGV4dC5oPgorI2VuZGlmCisKICNpZiBP UyhXSU5ET1dTKQogI2luY2x1ZGUgIlJlbmRlclRoZW1lQ2hyb21pdW1XaW4uaCIKICNlbHNlCkBA IC05NTUsNiArOTU5LDcgQEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52 YXMsIGNvbnN0IFdlYlJlY3QmIHJlY3QpCiAgICAgICAgICAgICB3ZWJmcmFtZS0+cGFpbnQoY2Fu dmFzLCByZWN0KTsKICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCiAgICAgfSBlbHNl IHsKKwogICAgICAgICAvLyBEcmF3IHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllci4KICAg ICAgICAgdXBkYXRlUm9vdExheWVyQ29udGVudHMocmVjdCk7CiAKQEAgLTk3MSw2ICs5NzYsOTEg QEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdlYlJl Y3QmIHJlY3QpCiAKICAgICAgICAgLy8gQXNrIHRoZSBsYXllciBjb21wb3NpdG9yIHRvIHJlZHJh dyBhbGwgdGhlIGxheWVycy4KICAgICAgICAgbV9sYXllclJlbmRlcmVyLT5kcmF3TGF5ZXJzKHJl Y3QsIHZpc2libGVSZWN0LCBjb250ZW50UmVjdCwgSW50UG9pbnQodmlldy0+c2Nyb2xsWCgpLCB2 aWV3LT5zY3JvbGxZKCkpKTsKKworICAgICAgICAvLyBJZiBhIGNhbnZhcyB3YXMgcGFzc2VkIGlu LCB3ZSB1c2UgaXQgdG8gZ3JhYiBhIGNvcHkgb2YgdGhlCisgICAgICAgIC8vIGZyZXNobHktcmVu ZGVyZWQgcGl4ZWxzLgorICAgICAgICBpZiAoY2FudmFzKSB7CisgICAgICAgICAgICB2b2lkKiBw aXhlbHMgPSAwOworI2lmIFBMQVRGT1JNKFNLSUEpCisgICAgICAgICAgICBjb25zdCBTa0JpdG1h cCBiaXRtYXAgPSBjYW52YXMtPmdldERldmljZSgpLT5hY2Nlc3NCaXRtYXAoZmFsc2UpOworICAg ICAgICAgICAgaWYgKGJpdG1hcC5jb25maWcoKSA9PSBTa0JpdG1hcDo6a0FSR0JfODg4OF9Db25m aWcpIHsKKworICAgICAgICAgICAgICAgIGludCB3aWR0aCA9IGJpdG1hcC53aWR0aCgpOworICAg ICAgICAgICAgICAgIGludCBoZWlnaHQgPSBiaXRtYXAuaGVpZ2h0KCk7CisKKyAgICAgICAgICAg ICAgICBTa0F1dG9Mb2NrUGl4ZWxzIGJpdG1hcExvY2soYml0bWFwKTsKKworICAgICAgICAgICAg ICAgIGlmIChtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVXaWR0aCgpID09IHdpZHRo CisgICAgICAgICAgICAgICAgICAgICYmIG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVy ZUhlaWdodCgpID09IGhlaWdodCkgeworICAgICAgICAgICAgICAgICAgICBwaXhlbHMgPSBiaXRt YXAuZ2V0UGl4ZWxzKCk7CisgICAgICAgICAgICAgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0 RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCB3aWR0aCwgaGVpZ2h0KTsKKyAgICAgICAgICAgICAg ICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpbnQgd2lkdGhSZXNpemUgPSBtX2xheWVy UmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVXaWR0aCgpOworICAgICAgICAgICAgICAgICAgICBp bnQgaGVpZ2h0UmVzaXplID0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlSGVpZ2h0 KCk7CisKKyAgICAgICAgICAgICAgICAgICAgLy8gQ3JlYXRlIHRlbXAgYml0bWFwIG9mIGNvcnJl Y3Qgc2l6ZSB0byBjb3B5IHBpeGVscyBpbnRvLgorICAgICAgICAgICAgICAgICAgICBPd25QdHI8 c2tpYTo6UGxhdGZvcm1DYW52YXM+IGNhbnZhc1Jlc2l6ZSA9IE93blB0cjxza2lhOjpQbGF0Zm9y bUNhbnZhcz4obmV3IHNraWE6OlBsYXRmb3JtQ2FudmFzKCkpOworICAgICAgICAgICAgICAgICAg ICBpZiAoY2FudmFzUmVzaXplLmdldCgpICYmIGNhbnZhc1Jlc2l6ZS0+aW5pdGlhbGl6ZSh3aWR0 aFJlc2l6ZSwgaGVpZ2h0UmVzaXplLCB0cnVlKSkgeworICAgICAgICAgICAgICAgICAgICAgICAg U2tCaXRtYXAgYml0bWFwUmVzaXplID0gY2FudmFzUmVzaXplLT5nZXREZXZpY2UoKS0+YWNjZXNz Qml0bWFwKGZhbHNlKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHBpeGVscyA9IGJpdG1hcFJl c2l6ZS5nZXRQaXhlbHMoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIG1fbGF5ZXJSZW5kZXJl ci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCB3aWR0aFJlc2l6ZSwgaGVpZ2h0UmVzaXpl KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIFNrSVJlY3Qgc3JjUmVjdDsKKyAgICAgICAgICAg ICAgICAgICAgICAgIHNyY1JlY3Quc2V0KDAsIDAsIGJpdG1hcFJlc2l6ZS53aWR0aCgpLCBiaXRt YXBSZXNpemUuaGVpZ2h0KCkpOworICAgICAgICAgICAgICAgICAgICAgICAgU2tSZWN0IGRzdFJl Y3QgPSBTa1JlY3Q6Ok1ha2VXSChiaXRtYXAud2lkdGgoKSwgYml0bWFwLmhlaWdodCgpKTsKKyAg ICAgICAgICAgICAgICAgICAgICAgIGNhbnZhcy0+ZHJhd0JpdG1hcFJlY3QoYml0bWFwUmVzaXpl LCAmc3JjUmVjdCwgZHN0UmVjdCwgMCk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIGJpdG1hcC5l cmFzZUNvbG9yKFNrQ29sb3JTZXRBUkdCKDAsIDAsIDAsIDApKTsKKyAgICAgICAgICAgICAgICBB U1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgICAgIH0KKyNlbGlmIFBMQVRGT1JNKENHKQor ICAgICAgICAgICAgQ0dDb250ZXh0UmVmIGJpdG1hcCA9IHJlaW50ZXJwcmV0X2Nhc3Q8Q0dDb250 ZXh0UmVmPihjYW52YXMpOworICAgICAgICAgICAgaWYgKENHQml0bWFwQ29udGV4dEdldFJvd0J5 dGVzKGJpdG1hcCkgPT0gNCAqIHdpZHRoKSB7CisKKyAgICAgICAgICAgICAgICBpbnQgd2lkdGgg PSBDR0JpdG1hcENvbnRleHRHZXRXaWR0aChiaXRtYXApOworICAgICAgICAgICAgICAgIGludCBo ZWlnaHQgPSBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQoYml0bWFwKTsKKworICAgICAgICAgICAg ICAgIGlmIChtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVXaWR0aCgpID09IHdpZHRo CisgICAgICAgICAgICAgICAgICAgICYmIG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVy ZUhlaWdodCgpID09IGhlaWdodCkgeworICAgICAgICAgICAgICAgICAgcGl4ZWxzID0gQ0dCaXRt YXBDb250ZXh0R2V0RGF0YShiaXRtYXApOworICAgICAgICAgICAgICAgICAgbV9sYXllclJlbmRl cmVyLT5nZXRGcmFtZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHdpZHRoLCBoZWlnaHQpOworICAgICAg ICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgICAgIGludCB3aWR0aFJlc2l6ZSA9 IG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVdpZHRoKCk7CisgICAgICAgICAgICAg ICAgICAgIGludCBoZWlnaHRSZXNpemUgPSBtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1 cmVIZWlnaHQoKTsKKworICAgICAgICAgICAgICAgICAgICAvLyBDcmVhdGUgdGVtcCBiaXRtYXAg b2Ygc2FtZSBzaXplIGFzIHJlbmRlcmVkIGxheWVyIHRvIGNvcHkgcGl4ZWxzIGludG8uCisgICAg ICAgICAgICAgICAgICAgIENHQ29sb3JTcGFjZVJlZiBjb2xvclNwYWNlID0gQ0dDb2xvclNwYWNl Q3JlYXRlRGV2aWNlUkdCKCk7CisgICAgICAgICAgICAgICAgICAgIENHQ29udGV4dFJlZiBiaXRt YXBSZXNpemUgPSBDR0JpdG1hcENvbnRleHRDcmVhdGUoMCwgd2lkdGhSZXNpemUsIGhlaWdodFJl c2l6ZSwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgOCwgNCAqIHdpZHRoUmVzaXplLCBjb2xvclNwYWNlLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGtDR0ltYWdlQWxwaGFQcmVtdWx0aXBsaWVkTGFzdCk7CisgICAgICAgICAgICAg ICAgICAgIGlmIChiaXRtYXBSZXNpemUpIHsKKyAgICAgICAgICAgICAgICAgICAgICBwaXhlbHMg PSBDR0JpdG1hcENvbnRleHRHZXREYXRhKGJpdG1hcFJlc2l6ZSk7CisgICAgICAgICAgICAgICAg ICAgICAgbV9sYXllclJlbmRlcmVyLT5nZXRGcmFtZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHdpZHRo UmVzaXplLCBoZWlnaHRSZXNpemUpOworCisgICAgICAgICAgICAgICAgICAgICAgLy8gQ29weSBi aXRtYXAgYmFjayB0byBpbnB1dCBiaXRtYXAuIFRoZSBpbWFnZSBpcyBpbnZlcnRlZCBhY2NvcmRp bmcgdG8gQ0csCisgICAgICAgICAgICAgICAgICAgICAgLy8gc28gc2V0IHVwIHRoZSBhcHByb3By aWF0ZSB0cmFuc2Zvcm0gdG8gaW52ZXJ0IHZlcnRpY2FsIGF4aXMgYW5kIG1vdmUgb3JpZ2luCisg ICAgICAgICAgICAgICAgICAgICAgLy8gdG8gYm90dG9tIGxlZnQuCisgICAgICAgICAgICAgICAg ICAgICAgQ0dDb250ZXh0U2F2ZUdTdGF0ZShiaXRtYXApOworICAgICAgICAgICAgICAgICAgICAg IENHQ29udGV4dFRyYW5zbGF0ZUNUTShiaXRtYXAsIDAsIENHQml0bWFwQ29udGV4dEdldEhlaWdo dChiaXRtYXApKTsKKyAgICAgICAgICAgICAgICAgICAgICBDR0NvbnRleHRTY2FsZUNUTShiaXRt YXAsIDEuMCwgLTEuMCk7CisgICAgICAgICAgICAgICAgICAgICAgQ0dDb250ZXh0RHJhd0ltYWdl KGJpdG1hcCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ0dSZWN0 TWFrZSgwLCAwLCBDR0JpdG1hcENvbnRleHRHZXRXaWR0aChiaXRtYXApLCBDR0JpdG1hcENvbnRl eHRHZXRIZWlnaHQoYml0bWFwKSksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIENHQml0bWFwQ29udGV4dENyZWF0ZUltYWdlKGJpdG1hcFJlc2l6ZSkpOworICAgICAg ICAgICAgICAgICAgICAgIENHQ29udGV4dFJlc3RvcmVHU3RhdGUoYml0bWFwKTsKKyAgICAgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzZSB7Cisg ICAgICAgICAgICAgICAgQ0dDb250ZXh0Q2xlYXJSZWN0KGJpdG1hcCwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgQ0dSZWN0TWFrZSgwLCAwLCBDR0JpdG1hcENvbnRleHRHZXRX aWR0aChiaXRtYXApLCBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQoYml0bWFwKSkpOworICAgICAg ICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgfQorI2Vsc2UKKyNl cnJvciBNdXN0IHBvcnQgdG8geW91ciBwbGF0Zm9ybS4KKyNlbmRpZgorICAgICAgICB9CisKKyAg ICAgICAgbV9sYXllclJlbmRlcmVyLT5wcmVzZW50KCk7IC8vIERvIGZpbmFsIGRpc3BsYXkgYnkg c3dhcHBpbmcgYnVmZmVycy4KICAgICB9CiAjZW5kaWYKIH0K 66402 2010-09-02 13:05:00 -0700 2010-09-03 09:08:13 -0700 Patch bug-44127-20100902160459.patch text/plain 12512 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NDRiMTVmNDExZDMwYzZmZWY2MjMzYWNjNmFlN2E3ZWVkZTdlYjEwZi4uOTkyNmU4ZDBhYjRiMDIz YWJhNGU0Nzc1MDUwMjYzNDQxZjU1ZDYyZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMiBAQAorMjAxMC0wOS0wMiAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKworICAgICAgICBBZGRz IHBpeGVsLXJlYWRiYWNrIGZvciBHUFUgY29tcG9zaXRlZCBwYWdlcyB0byBhbGxvdyBmb3IgdGh1 bWJuYWlsaW5nLAorICAgICAgICBwcmludGluZyBhbmQgb3RoZXIgc2VydmljZXMgdG8gd29yayB3 aXRoIEdQVSByZW5kZXJlZCBwYWdlcy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXll clJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpwcmVzZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVy ZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29y ZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlU2l6ZSk6CisKIDIwMTAt MDktMDIgIEFuZHJlYXMgS2xpbmcgIDxhbmRyZWFzLmtsaW5nQG5va2lhLmNvbT4KIAogICAgICAg ICBSdWJiZXItc3RhbXBlZCBieSBTaW1vbiBIYXVzbWFubi4KZGlmZiAtLWdpdCBhL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcCBiL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNw cAppbmRleCA1MDMzOGQyZDVmNzMyNGU1YTExOWM1MDkxOTBkZmVmODY5OGIxNzY5Li42NWRmOThl MDNlMGQxYzUxNDU3MTYxZTlkMzA4MzY5YjQ5ZjBkZjY5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKKysrIGIv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0u Y3BwCkBAIC0zOSw2ICszOSw3IEBACiAjaW5jbHVkZSAiR0xFUzJDb250ZXh0LmgiCiAjaW5jbHVk ZSAiTGF5ZXJDaHJvbWl1bS5oIgogI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCisjaW5jbHVk ZSA8d3RmL093bkFycmF5UHRyLmg+CiAjaWYgUExBVEZPUk0oU0tJQSkKICNpbmNsdWRlICJOYXRp dmVJbWFnZVNraWEuaCIKICNpbmNsdWRlICJQbGF0Zm9ybUNvbnRleHRTa2lhLmgiCkBAIC0zMjEs MTEgKzMyMiw0MSBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6ZHJhd0xheWVycyhjb25z dCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0JgogCiAgICAgR0xDKGdsRGlzYWJs ZShHTF9TQ0lTU09SX1RFU1QpKTsKIAorICAgIGdsRmx1c2goKTsKK30KKwordm9pZCBMYXllclJl bmRlcmVyQ2hyb21pdW06OnByZXNlbnQoKQorewogICAgIG1fZ2xlczJDb250ZXh0LT5zd2FwQnVm ZmVycygpOwogCiAgICAgbV9uZWVkc0Rpc3BsYXkgPSBmYWxzZTsKIH0KIAordm9pZCBMYXllclJl bmRlcmVyQ2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3Qg SW50U2l6ZSYgc2l6ZSkKK3sKKyAgICBBU1NFUlQoc2l6ZSA9PSByb290TGF5ZXJUZXh0dXJlU2l6 ZSgpKTsKKworICAgIGlmICghcGl4ZWxzKQorICAgICAgICByZXR1cm47CisKKyAgICBtYWtlQ29u dGV4dEN1cnJlbnQoKTsKKworICAgIEdMQyhnbFJlYWRQaXhlbHMoMCwgMCwgc2l6ZS53aWR0aCgp LCBzaXplLmhlaWdodCgpLAorICAgICAgICAgICAgICAgICAgICAgR0xfUkdCQSwgR0xfVU5TSUdO RURfQllURSwgcGl4ZWxzKSk7CisKKyAgICAvLyBGbGlwIHBpeGVscyB2ZXJ0aWNhbGx5LgorICAg IGNvbnN0IGludCByb3dCeXRlcyA9IDQgKiBzaXplLndpZHRoKCk7CisgICAgT3duQXJyYXlQdHI8 dW5zaWduZWQgY2hhcj4gbGluZVRlbXAobmV3IHVuc2lnbmVkIGNoYXJbcm93Qnl0ZXNdKTsKKyAg ICBmb3IgKGludCByb3cxID0gMCwgcm93MiA9IHNpemUuaGVpZ2h0KCkgLSAxOyByb3cxIDwgc2l6 ZS5oZWlnaHQoKSAvIDI7ICsrcm93MSwgLS1yb3cyKSB7CisgICAgICAgIHVuc2lnbmVkIGNoYXIq IHB0cjEgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4ocGl4ZWxzKSArIHJvdzEgKiByb3dC eXRlczsKKyAgICAgICAgdW5zaWduZWQgY2hhciogcHRyMiA9IHN0YXRpY19jYXN0PHVuc2lnbmVk IGNoYXIqPihwaXhlbHMpICsgcm93MiAqIHJvd0J5dGVzOworCisgICAgICAgIG1lbWNweShsaW5l VGVtcC5nZXQoKSwgcHRyMSwgcm93Qnl0ZXMpOworICAgICAgICBtZW1jcHkocHRyMSwgcHRyMiwg cm93Qnl0ZXMpOworICAgICAgICBtZW1jcHkocHRyMiwgbGluZVRlbXAuZ2V0KCksIHJvd0J5dGVz KTsKKyAgICB9Cit9CisKIC8vIEZJWE1FOiBUaGlzIG1ldGhvZCBzaG91bGQgZXZlbnR1YWxseSBi ZSByZXBsYWNlZCBieSBhIHByb3BlciB0ZXh0dXJlIG1hbmFnZXIuCiB1bnNpZ25lZCBMYXllclJl bmRlcmVyQ2hyb21pdW06OmNyZWF0ZUxheWVyVGV4dHVyZSgpCiB7CmRpZmYgLS1naXQgYS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oIGIv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0u aAppbmRleCA4ZjQ0YWZlYmQwYTJjN2I0NzVkMDRiYTQ4NzIzZjFjZGM1NDU1MDkxLi5kNTNkYzM3 ZmZkZjc1OTJiY2JlZTkxMzJiYzU5MjRkZDU3NGU0OTdiIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCisrKyBiL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgK QEAgLTY0LDYgKzY0LDcgQEAgcHVibGljOgogICAgIC8vIFVwZGF0ZXMgdGhlIGNvbnRlbnRzIG9m IHRoZSByb290IGxheWVyIHRoYXQgZmFsbCBpbnNpZGUgdGhlIHVwZGF0ZVJlY3QgYW5kIHJlY29t cG9zaXRlcwogICAgIC8vIGFsbCB0aGUgbGF5ZXJzLgogICAgIHZvaWQgZHJhd0xheWVycyhjb25z dCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0JiB2aXNpYmxlUmVjdCwgY29uc3Qg SW50UmVjdCYgY29udGVudFJlY3QsIGNvbnN0IEludFBvaW50JiBzY3JvbGxQb3NpdGlvbik7Cisg ICAgdm9pZCBwcmVzZW50KCk7IC8vIFBlcmZvcm0gYnVmZmVyIHN3YXAgdG8gcHJlc2VudCByZW5k ZXJlZCBidWZmZXIuCiAKICAgICB2b2lkIHNldFJvb3RMYXllcihQYXNzUmVmUHRyPExheWVyQ2hy b21pdW0+IGxheWVyKSB7IG1fcm9vdExheWVyID0gbGF5ZXI7IH0KICAgICBMYXllckNocm9taXVt KiByb290TGF5ZXIoKSB7IHJldHVybiBtX3Jvb3RMYXllci5nZXQoKTsgfQpAQCAtOTAsNiArOTEs OSBAQCBwdWJsaWM6CiAgICAgY29uc3QgQ29udGVudExheWVyQ2hyb21pdW06OlNoYXJlZFZhbHVl cyogY29udGVudExheWVyU2hhcmVkVmFsdWVzKCkgY29uc3QgeyByZXR1cm4gbV9jb250ZW50TGF5 ZXJTaGFyZWRWYWx1ZXMuZ2V0KCk7IH0KICAgICBjb25zdCBDYW52YXNMYXllckNocm9taXVtOjpT aGFyZWRWYWx1ZXMqIGNhbnZhc0xheWVyU2hhcmVkVmFsdWVzKCkgY29uc3QgeyByZXR1cm4gbV9j YW52YXNMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsgfQogCisgICAgSW50U2l6ZSByb290TGF5ZXJU ZXh0dXJlU2l6ZSgpIGNvbnN0IHsgcmV0dXJuIEludFNpemUobV9yb290TGF5ZXJUZXh0dXJlV2lk dGgsIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCk7IH0KKyAgICB2b2lkIGdldEZyYW1lYnVmZmVy UGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgSW50U2l6ZSYgc2l6ZSk7CisKIHByaXZhdGU6CiAg ICAgdm9pZCB1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5ZXJDaHJvbWl1bSogbGF5ZXIsIGNvbnN0 IFRyYW5zZm9ybWF0aW9uTWF0cml4JiBwYXJlbnRNYXRyaXgsIGZsb2F0IG9wYWNpdHkpOwogCmRp ZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0L2Nocm9taXVtL0No YW5nZUxvZwppbmRleCA1MjdlOGVmY2NhZTM5MDQ1ZmQ5ODVkZWQzYmYyMGQ3MTY2YWZjNjlkLi42 NWYwZTlkNGQ5YTQyZDE2YmRjY2Q5Nzk4OGI0YWJiOGIxOTIyN2FiIDEwMDY0NAotLS0gYS9XZWJL aXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwyMyBAQAorMjAxMC0wOS0wMiAgVy4gSmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5vdCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJl ZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDQxMjcKKworICAgICAgICBNb2RpZmllZCBXZWJWaWV3SW1wbDo6cGFpbnQoKSB0byBkZXRlY3Qg bm9uLW51bGwgY2FudmFzIHBvaW50ZXJzIHdoZW4KKyAgICAgICAgYWNjZWxlcmF0ZWQgY29tcG9z aXRpbmcgaXMgYWN0aXZlLCBhbmQgaW5zdGVhZCBmaWxscyB0aGUgcGl4ZWwgYnVmZmVyCisgICAg ICAgIGZyb20gdGhlIEdQVSBmcmFtZWJ1ZmZlci4gSW5jbHVkZXMgcmUtc2NhbGluZyBzdXBwb3J0 IHdoZW4gcHJvdmlkZWQKKyAgICAgICAgY2FudmFzIGRvZXMgbm90IG1hdGNoIHNpemUgb2YgY3Vy cmVudCByZW5kZXIgbGF5ZXIuIExpbWl0cyBwaXhlbAorICAgICAgICByZWFkYmFjayB0byByZWN0 IHBhc3NlZCB0byBwYWludCgpLCBjbGlwcGVkIGJ5IHNpemUgb2Ygcm9vdExheWVyVGV4dHVyZS4K KworICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlZp ZXdJbXBsOjpwYWludCk6CisgICAgICAgIChXZWJLaXQ6OmNsZWFyU2tCaXRtYXApOgorICAgICAg ICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6ZG9QaXhlbFJlYWRiYWNrVG9DYW52YXMpOgorICAgICAg ICAoV2ViS2l0OjpjbGVhckNHQml0bWFwKToKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuaDoK KwogMjAxMC0wOS0wMiAgSWx5YSBTaGVybWFuICA8aXNoZXJtYW5AZ29vZ2xlLmNvbT4KIAogICAg ICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRlbC4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5j cHAKaW5kZXggNGIxMjlkNjk0YjFmMTEyZjI3YjIxYWU3MjRkYjY3YTY4YTc0ZTAyYS4uNzQ5ODBm MzU2YWFiMzE4ZDY4ZjZiMDY0YmQwYTk5ZmFjY2Q3MWEwOCAxMDA2NDQKLS0tIGEvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJW aWV3SW1wbC5jcHAKQEAgLTExNSw2ICsxMTUsMTAgQEAKICNpbmNsdWRlICJXZWJWaWV3Q2xpZW50 LmgiCiAjaW5jbHVkZSAid3RmL093blB0ci5oIgogCisjaWYgUExBVEZPUk0oQ0cpCisjaW5jbHVk ZSA8Q29yZUdyYXBoaWNzL0NHQ29udGV4dC5oPgorI2VuZGlmCisKICNpZiBPUyhXSU5ET1dTKQog I2luY2x1ZGUgIlJlbmRlclRoZW1lQ2hyb21pdW1XaW4uaCIKICNlbHNlCkBAIC05NTIsNiArOTU2 LDcgQEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdl YlJlY3QmIHJlY3QpCiAgICAgICAgICAgICB3ZWJmcmFtZS0+cGFpbnQoY2FudmFzLCByZWN0KTsK ICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCiAgICAgfSBlbHNlIHsKKwogICAgICAg ICAvLyBEcmF3IHRoZSBjb250ZW50cyBvZiB0aGUgcm9vdCBsYXllci4KICAgICAgICAgdXBkYXRl Um9vdExheWVyQ29udGVudHMocmVjdCk7CiAKQEAgLTk2OCwxMCArOTczLDEyNyBAQCB2b2lkIFdl YlZpZXdJbXBsOjpwYWludChXZWJDYW52YXMqIGNhbnZhcywgY29uc3QgV2ViUmVjdCYgcmVjdCkK IAogICAgICAgICAvLyBBc2sgdGhlIGxheWVyIGNvbXBvc2l0b3IgdG8gcmVkcmF3IGFsbCB0aGUg bGF5ZXJzLgogICAgICAgICBtX2xheWVyUmVuZGVyZXItPmRyYXdMYXllcnMocmVjdCwgdmlzaWJs ZVJlY3QsIGNvbnRlbnRSZWN0LCBJbnRQb2ludCh2aWV3LT5zY3JvbGxYKCksIHZpZXctPnNjcm9s bFkoKSkpOworCisgICAgICAgIC8vIElmIGEgY2FudmFzIHdhcyBwYXNzZWQgaW4sIHdlIHVzZSBp dCB0byBncmFiIGEgY29weSBvZiB0aGUKKyAgICAgICAgLy8gZnJlc2hseS1yZW5kZXJlZCBwaXhl bHMuCisgICAgICAgIGlmIChjYW52YXMpIHsKKyAgICAgICAgICAgIC8vIENsaXAgcmVjdCB0byB0 aGUgY29uZmluZXMgb2YgdGhlIHJvb3RMYXllclRleHR1cmUuCisgICAgICAgICAgICBpbnQgeE1h eCA9IG1pbihyZWN0LnggKyByZWN0LndpZHRoIC0gMSwgbV9sYXllclJlbmRlcmVyLT5yb290TGF5 ZXJUZXh0dXJlU2l6ZSgpLndpZHRoKCkgLSAxKTsKKyAgICAgICAgICAgIGludCB5TWF4ID0gbWlu KHJlY3QueSArIHJlY3QuaGVpZ2h0IC0gMSwgbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0 dXJlU2l6ZSgpLmhlaWdodCgpIC0gMSk7CisgICAgICAgICAgICBXZWJSZWN0IHJlc2l6ZVJlY3Qo cmVjdC54LCByZWN0LnksIHhNYXggLSByZWN0LnggKyAxLCB5TWF4IC0gcmVjdC55ICsgMSk7Cisg ICAgICAgICAgICBkb1BpeGVsUmVhZGJhY2tUb0NhbnZhcyhjYW52YXMsIHJlc2l6ZVJlY3QpOwor ICAgICAgICB9CisKKyAgICAgICAgbV9sYXllclJlbmRlcmVyLT5wcmVzZW50KCk7IC8vIERvIGZp bmFsIGRpc3BsYXkgYnkgc3dhcHBpbmcgYnVmZmVycy4KICAgICB9CiAjZW5kaWYKIH0KIAorI2lm IFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKKyNpZiBQTEFURk9STShTS0lBKQorc3RhdGlj IGlubGluZSB2b2lkIGNsZWFyU2tCaXRtYXAoY29uc3QgU2tCaXRtYXAmIGJpdG1hcCkKK3sKKyAg ICBiaXRtYXAuZXJhc2VDb2xvcihTa0NvbG9yU2V0QVJHQigwLCAwLCAwLCAwKSk7Cit9CisKK3Zv aWQgV2ViVmlld0ltcGw6OmRvUGl4ZWxSZWFkYmFja1RvQ2FudmFzKFdlYkNhbnZhcyogY2FudmFz LCBXZWJSZWN0JiByZWN0KQoreworICAgIEFTU0VSVCgocmVjdC54ICsgcmVjdC53aWR0aCAtMSkg PCBtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVTaXplKCkud2lkdGgoKQorICAgICAg ICAgICAmJiAocmVjdC55ICsgcmVjdC5oZWlnaHQgLTEpIDwgbV9sYXllclJlbmRlcmVyLT5yb290 TGF5ZXJUZXh0dXJlU2l6ZSgpLmhlaWdodCgpKTsKKworICAgIHZvaWQqIHBpeGVscyA9IDA7Cisg ICAgY29uc3QgU2tCaXRtYXAgYml0bWFwID0gY2FudmFzLT5nZXREZXZpY2UoKS0+YWNjZXNzQml0 bWFwKGZhbHNlKTsKKyAgICBpZiAoYml0bWFwLmNvbmZpZygpID09IFNrQml0bWFwOjprQVJHQl84 ODg4X0NvbmZpZykgeworICAgICAgICBXZWJSZWN0IGJpdG1hcFJlY3QoMCwgMCwgYml0bWFwLndp ZHRoKCksIGJpdG1hcC5oZWlnaHQoKSk7CisgICAgICAgIEludFNpemUgc2l6ZShiaXRtYXBSZWN0 LndpZHRoLCBiaXRtYXBSZWN0LmhlaWdodCk7CisKKyAgICAgICAgU2tBdXRvTG9ja1BpeGVscyBi aXRtYXBMb2NrKGJpdG1hcCk7CisKKyAgICAgICAgaWYgKHJlY3QgPT0gYml0bWFwUmVjdCkgewor ICAgICAgICAgICAgcGl4ZWxzID0gYml0bWFwLmdldFBpeGVscygpOworICAgICAgICAgICAgbV9s YXllclJlbmRlcmVyLT5nZXRGcmFtZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHNpemUpOworICAgICAg ICB9IGVsc2UgeworICAgICAgICAgICAgSW50U2l6ZSByZXNpemUocmVjdC54ICsgcmVjdC53aWR0 aCwgcmVjdC55ICsgcmVjdC5oZWlnaHQpOworCisgICAgICAgICAgICAvLyBDcmVhdGUgdGVtcCBi aXRtYXAgb2YgY29ycmVjdCBzaXplIHRvIGNvcHkgcGl4ZWxzIGludG8uCisgICAgICAgICAgICBz a2lhOjpQbGF0Zm9ybUNhbnZhcyBjYW52YXNSZXNpemU7CisgICAgICAgICAgICBpZiAoY2FudmFz UmVzaXplLmluaXRpYWxpemUocmVzaXplLndpZHRoKCksIHJlc2l6ZS5oZWlnaHQoKSwgdHJ1ZSkp IHsKKyAgICAgICAgICAgICAgICBTa0JpdG1hcCBiaXRtYXBSZXNpemUgPSBjYW52YXNSZXNpemUu Z2V0RGV2aWNlKCktPmFjY2Vzc0JpdG1hcChmYWxzZSk7CisgICAgICAgICAgICAgICAgcGl4ZWxz ID0gYml0bWFwUmVzaXplLmdldFBpeGVscygpOworICAgICAgICAgICAgICAgIG1fbGF5ZXJSZW5k ZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCByZXNpemUpOworICAgICAgICAgICAg ICAgIFNrSVJlY3Qgc3JjUmVjdDsKKyAgICAgICAgICAgICAgICBzcmNSZWN0LnNldChyZWN0Lngs IHJlY3QueSwgcmVjdC53aWR0aCwgcmVjdC5oZWlnaHQpOworICAgICAgICAgICAgICAgIFNrUmVj dCBkc3RSZWN0ID0gU2tSZWN0OjpNYWtlV0goYml0bWFwLndpZHRoKCksIGJpdG1hcC5oZWlnaHQo KSk7CisgICAgICAgICAgICAgICAgY2FudmFzLT5kcmF3Qml0bWFwUmVjdChiaXRtYXBSZXNpemUs ICZzcmNSZWN0LCBkc3RSZWN0LCAwKTsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAg ICAgICAgY2xlYXJTa0JpdG1hcChiaXRtYXApOworICAgICAgICAgICAgICAgIEFTU0VSVF9OT1Rf UkVBQ0hFRCgpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfSBlbHNlIHsKKyAgICAg ICAgY2xlYXJTa0JpdG1hcChiaXRtYXApOworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsK KyAgICB9Cit9CisKKyNlbGlmIFBMQVRGT1JNKENHKQorc3RhdGljIGlubGluZSB2b2lkIGNsZWFy Q0dCaXRtYXAoY29uc3QgQ0dDb250ZXh0UmVmJiBiaXRtYXApCit7CisgICAgQ0dDb250ZXh0Q2xl YXJSZWN0KGJpdG1hcCwKKyAgICAgICAgICAgICAgICAgICAgICAgQ0dSZWN0TWFrZSgwLCAwLCBD R0JpdG1hcENvbnRleHRHZXRXaWR0aChiaXRtYXApLCBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQo Yml0bWFwKSkpOworfQorCit2b2lkIFdlYlZpZXdJbXBsOjpkb1BpeGVsUmVhZGJhY2tUb0NhbnZh cyhXZWJDYW52YXMqIGNhbnZhcywgV2ViUmVjdCYgcmVjdCkKK3sKKyAgICBBU1NFUlQoKHJlY3Qu eCArIHJlY3Qud2lkdGggLTEpIDwgbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlU2l6 ZSgpLndpZHRoKCkKKyAgICAgICAgICAgJiYgKHJlY3QueSArIHJlY3QuaGVpZ2h0IC0xKSA8IG1f bGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVNpemUoKS5oZWlnaHQoKSk7CisKKyAgICB2 b2lkKiBwaXhlbHMgPSAwOworICAgIENHQ29udGV4dFJlZiBiaXRtYXAgPSByZWludGVycHJldF9j YXN0PENHQ29udGV4dFJlZj4oY2FudmFzKTsKKyAgICBXZWJSZWN0IGJpdG1hcFJlY3QoMCwgMCwg Q0dCaXRtYXBDb250ZXh0R2V0V2lkdGgoYml0bWFwKSwgQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0 KGJpdG1hcCkpOworICAgIEludFNpemUgc2l6ZShiaXRtYXBSZWN0LndpZHRoLCBiaXRtYXBSZWN0 LmhlaWdodCk7CisgICAgaWYgKENHQml0bWFwQ29udGV4dEdldFJvd0J5dGVzKGJpdG1hcCkgPT0g NCAqIGJpdG1hcFJlY3Qud2lkdGgpIHsKKyAgICAgICAgaWYgKHJlY3QgPT0gYml0bWFwUmVjdCkg eworICAgICAgICAgIHBpeGVscyA9IENHQml0bWFwQ29udGV4dEdldERhdGEoYml0bWFwKTsKKyAg ICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdldEZyYW1lYnVmZmVyUGl4ZWxzKHBpeGVscywgc2l6 ZSk7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBJbnRTaXplIHJlc2l6ZShyZWN0Lngg KyByZWN0LndpZHRoLCByZWN0LnkgKyByZWN0LmhlaWdodCk7CisKKyAgICAgICAgICAgIC8vIENy ZWF0ZSB0ZW1wIGJpdG1hcCBvZiBzYW1lIHNpemUgYXMgcmVuZGVyZWQgbGF5ZXIgdG8gY29weSBw aXhlbHMgaW50by4KKyAgICAgICAgICAgIENHQ29sb3JTcGFjZVJlZiBjb2xvclNwYWNlID0gQ0dD b2xvclNwYWNlQ3JlYXRlRGV2aWNlUkdCKCk7CisgICAgICAgICAgICBDR0NvbnRleHRSZWYgYml0 bWFwUmVzaXplID0gQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKDAsIHJlc2l6ZS53aWR0aCgpLCByZXNp emUuaGVpZ2h0KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIDgsIDQgKiByZXNpemUud2lkdGgoKSwgY29sb3JTcGFjZSwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRMYXN0KTsKKyAgICAgICAgICAgIGlmIChiaXRt YXBSZXNpemUpIHsKKyAgICAgICAgICAgICAgcGl4ZWxzID0gQ0dCaXRtYXBDb250ZXh0R2V0RGF0 YShiaXRtYXBSZXNpemUpOworICAgICAgICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdldEZyYW1l YnVmZmVyUGl4ZWxzKHBpeGVscywgcmVzaXplKTsKKworICAgICAgICAgICAgICAvLyBDb3B5IGJp dG1hcCBiYWNrIHRvIGlucHV0IGJpdG1hcC4gVGhlIGltYWdlIGlzIGludmVydGVkIGFjY29yZGlu ZyB0byBDRywKKyAgICAgICAgICAgICAgLy8gc28gc2V0IHVwIHRoZSBhcHByb3ByaWF0ZSB0cmFu c2Zvcm0gdG8gaW52ZXJ0IHZlcnRpY2FsIGF4aXMgYW5kIG1vdmUgb3JpZ2luCisgICAgICAgICAg ICAgIC8vIHRvIGJvdHRvbSBsZWZ0LgorICAgICAgICAgICAgICBDR0NvbnRleHRTYXZlR1N0YXRl KGJpdG1hcCk7CisgICAgICAgICAgICAgIENHQ29udGV4dFRyYW5zbGF0ZUNUTShiaXRtYXAsIDAs IGJpdG1hcFJlY3QuaGVpZ2h0KTsKKyAgICAgICAgICAgICAgQ0dDb250ZXh0U2NhbGVDVE0oYml0 bWFwLCAxLjAsIC0xLjApOworICAgICAgICAgICAgICBDR0NvbnRleHREcmF3SW1hZ2UoYml0bWFw LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ0dSZWN0TWFrZShiaXRtYXBSZWN0 LngsIGJpdG1hcFJlY3QueSwgYml0bWFwUmVjdC53aWR0aCwgYml0bWFwUmVjdC5oZWlnaHQpLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlSW1h Z2UoYml0bWFwUmVzaXplKSk7CisgICAgICAgICAgICAgIENHQ29udGV4dFJlc3RvcmVHU3RhdGUo Yml0bWFwKTsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgY2xlYXJDR0Jp dG1hcChiaXRtYXApOworICAgICAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAg ICAgICAgICAgfQorICAgICAgICB9CisgICAgfSBlbHNlIHsKKyAgICAgICAgY2xlYXJDR0JpdG1h cChiaXRtYXApOworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9Cit9CisjZWxz ZQorI2Vycm9yIE11c3QgcG9ydCB0byB5b3VyIHBsYXRmb3JtLgorI2VuZGlmCisKKyNlbmRpZgor CiAvLyBGSVhNRTogbV9jdXJyZW50SW5wdXRFdmVudCBzaG91bGQgYmUgcmVtb3ZlZCBvbmNlIENo cm9tZUNsaWVudDo6c2hvdygpIGNhbgogLy8gZ2V0IHRoZSBjdXJyZW50LWV2ZW50IGluZm9ybWF0 aW9uIGZyb20gV2ViQ29yZS4KIGNvbnN0IFdlYklucHV0RXZlbnQqIFdlYlZpZXdJbXBsOjptX2N1 cnJlbnRJbnB1dEV2ZW50ID0gMDsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi Vmlld0ltcGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAppbmRleCBjMjk2 MTIxMjNmNDUxNGM5NGRkN2Q5NzBjNzMxMTRhNGJlZWVjMzU1Li5mZDc1YTIwMTE3ZjlmZmRiOTgy MjNjOTQ5OGQ0ZWU3YWU5ODY0M2ZkIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YlZpZXdJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBAIC0z ODYsNiArMzg2LDcgQEAgcHJpdmF0ZToKICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcp CiAgICAgdm9pZCBzZXRJc0FjY2VsZXJhdGVkQ29tcG9zaXRpbmdBY3RpdmUoYm9vbCk7CiAgICAg dm9pZCB1cGRhdGVSb290TGF5ZXJDb250ZW50cyhjb25zdCBXZWJSZWN0Jik7CisgICAgdm9pZCBk b1BpeGVsUmVhZGJhY2tUb0NhbnZhcyhXZWJDYW52YXMqLCBXZWJSZWN0Jik7CiAjZW5kaWYKIAog ICAgIFdlYlZpZXdDbGllbnQqIG1fY2xpZW50Owo= 66505 2010-09-03 09:08:19 -0700 2010-09-03 10:59:28 -0700 Patch bug-44127-20100903120823.patch text/plain 12340 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NDRiMTVmNDExZDMwYzZmZWY2MjMzYWNjNmFlN2E3ZWVkZTdlYjEwZi4uOTkyNmU4ZDBhYjRiMDIz YWJhNGU0Nzc1MDUwMjYzNDQxZjU1ZDYyZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMiBAQAorMjAxMC0wOS0wMiAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKworICAgICAgICBBZGRz IHBpeGVsLXJlYWRiYWNrIGZvciBHUFUgY29tcG9zaXRlZCBwYWdlcyB0byBhbGxvdyBmb3IgdGh1 bWJuYWlsaW5nLAorICAgICAgICBwcmludGluZyBhbmQgb3RoZXIgc2VydmljZXMgdG8gd29yayB3 aXRoIEdQVSByZW5kZXJlZCBwYWdlcy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXll clJlbmRlcmVyQ2hyb21pdW06OmRyYXdMYXllcnMpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpwcmVzZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVuZGVy ZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29y ZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlU2l6ZSk6CisKIDIwMTAt MDktMDIgIEFuZHJlYXMgS2xpbmcgIDxhbmRyZWFzLmtsaW5nQG5va2lhLmNvbT4KIAogICAgICAg ICBSdWJiZXItc3RhbXBlZCBieSBTaW1vbiBIYXVzbWFubi4KZGlmZiAtLWdpdCBhL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcCBiL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNw cAppbmRleCA1MDMzOGQyZDVmNzMyNGU1YTExOWM1MDkxOTBkZmVmODY5OGIxNzY5Li41YzNjMGIx YjMxNjU2NGY0ZGFkNWJhZWYwZmViNDU4ZjExZmVlMTUwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKKysrIGIv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0u Y3BwCkBAIC0zOSw2ICszOSw3IEBACiAjaW5jbHVkZSAiR0xFUzJDb250ZXh0LmgiCiAjaW5jbHVk ZSAiTGF5ZXJDaHJvbWl1bS5oIgogI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCisjaW5jbHVk ZSA8d3RmL093bkFycmF5UHRyLmg+CiAjaWYgUExBVEZPUk0oU0tJQSkKICNpbmNsdWRlICJOYXRp dmVJbWFnZVNraWEuaCIKICNpbmNsdWRlICJQbGF0Zm9ybUNvbnRleHRTa2lhLmgiCkBAIC0zMjEs MTEgKzMyMiw0MSBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6ZHJhd0xheWVycyhjb25z dCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0JgogCiAgICAgR0xDKGdsRGlzYWJs ZShHTF9TQ0lTU09SX1RFU1QpKTsKIAorICAgIGdsRmx1c2goKTsKK30KKwordm9pZCBMYXllclJl bmRlcmVyQ2hyb21pdW06OnByZXNlbnQoKQorewogICAgIG1fZ2xlczJDb250ZXh0LT5zd2FwQnVm ZmVycygpOwogCiAgICAgbV9uZWVkc0Rpc3BsYXkgPSBmYWxzZTsKIH0KIAordm9pZCBMYXllclJl bmRlcmVyQ2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3Qg SW50UmVjdCYgcmVjdCkKK3sKKyAgICBBU1NFUlQocmVjdC5zaXplKCkgPT0gcm9vdExheWVyVGV4 dHVyZVNpemUoKSk7CisKKyAgICBpZiAoIXBpeGVscykKKyAgICAgICAgcmV0dXJuOworCisgICAg bWFrZUNvbnRleHRDdXJyZW50KCk7CisKKyAgICBHTEMoZ2xSZWFkUGl4ZWxzKHJlY3QueCgpLCBy ZWN0LnkoKSwgcmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpLAorICAgICAgICAgICAgICAgICAg ICAgR0xfUkdCQSwgR0xfVU5TSUdORURfQllURSwgcGl4ZWxzKSk7CisKKyAgICAvLyBGbGlwIHBp eGVscyB2ZXJ0aWNhbGx5LgorICAgIGNvbnN0IGludCByb3dCeXRlcyA9IDQgKiByZWN0LndpZHRo KCk7CisgICAgT3duQXJyYXlQdHI8dW5zaWduZWQgY2hhcj4gbGluZVRlbXAobmV3IHVuc2lnbmVk IGNoYXJbcm93Qnl0ZXNdKTsKKyAgICBmb3IgKGludCByb3cxID0gMCwgcm93MiA9IHJlY3QuaGVp Z2h0KCkgLSAxOyByb3cxIDwgcmVjdC5oZWlnaHQoKSAvIDI7ICsrcm93MSwgLS1yb3cyKSB7Cisg ICAgICAgIHVuc2lnbmVkIGNoYXIqIHB0cjEgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4o cGl4ZWxzKSArIHJvdzEgKiByb3dCeXRlczsKKyAgICAgICAgdW5zaWduZWQgY2hhciogcHRyMiA9 IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXIqPihwaXhlbHMpICsgcm93MiAqIHJvd0J5dGVzOwor CisgICAgICAgIG1lbWNweShsaW5lVGVtcC5nZXQoKSwgcHRyMSwgcm93Qnl0ZXMpOworICAgICAg ICBtZW1jcHkocHRyMSwgcHRyMiwgcm93Qnl0ZXMpOworICAgICAgICBtZW1jcHkocHRyMiwgbGlu ZVRlbXAuZ2V0KCksIHJvd0J5dGVzKTsKKyAgICB9Cit9CisKIC8vIEZJWE1FOiBUaGlzIG1ldGhv ZCBzaG91bGQgZXZlbnR1YWxseSBiZSByZXBsYWNlZCBieSBhIHByb3BlciB0ZXh0dXJlIG1hbmFn ZXIuCiB1bnNpZ25lZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmNyZWF0ZUxheWVyVGV4dHVyZSgp CiB7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVy UmVuZGVyZXJDaHJvbWl1bS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXllclJlbmRlcmVyQ2hyb21pdW0uaAppbmRleCA4ZjQ0YWZlYmQwYTJjN2I0NzVkMDRiYTQ4NzIz ZjFjZGM1NDU1MDkxLi5mZmU0MTQyM2Q1M2UzZjU0MGU3MTAyMzNmYWYyYTBmODE1NjJjZTU3IDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVy ZXJDaHJvbWl1bS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5 ZXJSZW5kZXJlckNocm9taXVtLmgKQEAgLTY0LDYgKzY0LDcgQEAgcHVibGljOgogICAgIC8vIFVw ZGF0ZXMgdGhlIGNvbnRlbnRzIG9mIHRoZSByb290IGxheWVyIHRoYXQgZmFsbCBpbnNpZGUgdGhl IHVwZGF0ZVJlY3QgYW5kIHJlY29tcG9zaXRlcwogICAgIC8vIGFsbCB0aGUgbGF5ZXJzLgogICAg IHZvaWQgZHJhd0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0 JiB2aXNpYmxlUmVjdCwgY29uc3QgSW50UmVjdCYgY29udGVudFJlY3QsIGNvbnN0IEludFBvaW50 JiBzY3JvbGxQb3NpdGlvbik7CisgICAgdm9pZCBwcmVzZW50KCk7IC8vIFBlcmZvcm0gYnVmZmVy IHN3YXAgdG8gcHJlc2VudCByZW5kZXJlZCBidWZmZXIuCiAKICAgICB2b2lkIHNldFJvb3RMYXll cihQYXNzUmVmUHRyPExheWVyQ2hyb21pdW0+IGxheWVyKSB7IG1fcm9vdExheWVyID0gbGF5ZXI7 IH0KICAgICBMYXllckNocm9taXVtKiByb290TGF5ZXIoKSB7IHJldHVybiBtX3Jvb3RMYXllci5n ZXQoKTsgfQpAQCAtOTAsNiArOTEsOSBAQCBwdWJsaWM6CiAgICAgY29uc3QgQ29udGVudExheWVy Q2hyb21pdW06OlNoYXJlZFZhbHVlcyogY29udGVudExheWVyU2hhcmVkVmFsdWVzKCkgY29uc3Qg eyByZXR1cm4gbV9jb250ZW50TGF5ZXJTaGFyZWRWYWx1ZXMuZ2V0KCk7IH0KICAgICBjb25zdCBD YW52YXNMYXllckNocm9taXVtOjpTaGFyZWRWYWx1ZXMqIGNhbnZhc0xheWVyU2hhcmVkVmFsdWVz KCkgY29uc3QgeyByZXR1cm4gbV9jYW52YXNMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsgfQogCisg ICAgSW50U2l6ZSByb290TGF5ZXJUZXh0dXJlU2l6ZSgpIGNvbnN0IHsgcmV0dXJuIEludFNpemUo bV9yb290TGF5ZXJUZXh0dXJlV2lkdGgsIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCk7IH0KKyAg ICB2b2lkIGdldEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgSW50UmVjdCYg cmVjdCk7CisKIHByaXZhdGU6CiAgICAgdm9pZCB1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5ZXJD aHJvbWl1bSogbGF5ZXIsIGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0cml4JiBwYXJlbnRNYXRyaXgs IGZsb2F0IG9wYWNpdHkpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9n IGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCA1MjdlOGVmY2NhZTM5MDQ1ZmQ5ODVk ZWQzYmYyMGQ3MTY2YWZjNjlkLi42NWYwZTlkNGQ5YTQyZDE2YmRjY2Q5Nzk4OGI0YWJiOGIxOTIy N2FiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wOS0wMiAgVy4gSmFtZXMg TWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5vdCBnZW5l cmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBNb2RpZmllZCBXZWJWaWV3SW1w bDo6cGFpbnQoKSB0byBkZXRlY3Qgbm9uLW51bGwgY2FudmFzIHBvaW50ZXJzIHdoZW4KKyAgICAg ICAgYWNjZWxlcmF0ZWQgY29tcG9zaXRpbmcgaXMgYWN0aXZlLCBhbmQgaW5zdGVhZCBmaWxscyB0 aGUgcGl4ZWwgYnVmZmVyCisgICAgICAgIGZyb20gdGhlIEdQVSBmcmFtZWJ1ZmZlci4gSW5jbHVk ZXMgcmUtc2NhbGluZyBzdXBwb3J0IHdoZW4gcHJvdmlkZWQKKyAgICAgICAgY2FudmFzIGRvZXMg bm90IG1hdGNoIHNpemUgb2YgY3VycmVudCByZW5kZXIgbGF5ZXIuIExpbWl0cyBwaXhlbAorICAg ICAgICByZWFkYmFjayB0byByZWN0IHBhc3NlZCB0byBwYWludCgpLCBjbGlwcGVkIGJ5IHNpemUg b2Ygcm9vdExheWVyVGV4dHVyZS4KKworICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5jcHA6Cisg ICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBsOjpwYWludCk6CisgICAgICAgIChXZWJLaXQ6OmNs ZWFyU2tCaXRtYXApOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6ZG9QaXhlbFJlYWRi YWNrVG9DYW52YXMpOgorICAgICAgICAoV2ViS2l0OjpjbGVhckNHQml0bWFwKToKKyAgICAgICAg KiBzcmMvV2ViVmlld0ltcGwuaDoKKwogMjAxMC0wOS0wMiAgSWx5YSBTaGVybWFuICA8aXNoZXJt YW5AZ29vZ2xlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRlbC4KZGlmZiAt LWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKaW5kZXggNGIxMjlkNjk0YjFmMTEyZjI3YjIxYWU3MjRk YjY3YTY4YTc0ZTAyYS4uZDEwYjJhOGYxYWNiY2JlODQ5M2JjYTU4MGRlODFlMzE5ZjNmYTk1MiAx MDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTY0LDcgKzY0LDYgQEAKICNpbmNs dWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJJbWFnZS5oIgogI2luY2x1ZGUgIkluc3BlY3Rv ckNvbnRyb2xsZXIuaCIKLSNpbmNsdWRlICJJbnRSZWN0LmgiCiAjaW5jbHVkZSAiS2V5Ym9hcmRD b2Rlcy5oIgogI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJNSU1FVHlwZVJl Z2lzdHJ5LmgiCkBAIC0xMTUsNiArMTE0LDEwIEBACiAjaW5jbHVkZSAiV2ViVmlld0NsaWVudC5o IgogI2luY2x1ZGUgInd0Zi9Pd25QdHIuaCIKIAorI2lmIFBMQVRGT1JNKENHKQorI2luY2x1ZGUg PENvcmVHcmFwaGljcy9DR0NvbnRleHQuaD4KKyNlbmRpZgorCiAjaWYgT1MoV0lORE9XUykKICNp bmNsdWRlICJSZW5kZXJUaGVtZUNocm9taXVtV2luLmgiCiAjZWxzZQpAQCAtOTUyLDYgKzk1NSw3 IEBAIHZvaWQgV2ViVmlld0ltcGw6OnBhaW50KFdlYkNhbnZhcyogY2FudmFzLCBjb25zdCBXZWJS ZWN0JiByZWN0KQogICAgICAgICAgICAgd2ViZnJhbWUtPnBhaW50KGNhbnZhcywgcmVjdCk7CiAj aWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQogICAgIH0gZWxzZSB7CisKICAgICAgICAg Ly8gRHJhdyB0aGUgY29udGVudHMgb2YgdGhlIHJvb3QgbGF5ZXIuCiAgICAgICAgIHVwZGF0ZVJv b3RMYXllckNvbnRlbnRzKHJlY3QpOwogCkBAIC05NjgsMTAgKzk3MiwxMTggQEAgdm9pZCBXZWJW aWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdlYlJlY3QmIHJlY3QpCiAK ICAgICAgICAgLy8gQXNrIHRoZSBsYXllciBjb21wb3NpdG9yIHRvIHJlZHJhdyBhbGwgdGhlIGxh eWVycy4KICAgICAgICAgbV9sYXllclJlbmRlcmVyLT5kcmF3TGF5ZXJzKHJlY3QsIHZpc2libGVS ZWN0LCBjb250ZW50UmVjdCwgSW50UG9pbnQodmlldy0+c2Nyb2xsWCgpLCB2aWV3LT5zY3JvbGxZ KCkpKTsKKworICAgICAgICAvLyBJZiBhIGNhbnZhcyB3YXMgcGFzc2VkIGluLCB3ZSB1c2UgaXQg dG8gZ3JhYiBhIGNvcHkgb2YgdGhlCisgICAgICAgIC8vIGZyZXNobHktcmVuZGVyZWQgcGl4ZWxz LgorICAgICAgICBpZiAoY2FudmFzKSB7CisgICAgICAgICAgICAvLyBDbGlwIHJlY3QgdG8gdGhl IGNvbmZpbmVzIG9mIHRoZSByb290TGF5ZXJUZXh0dXJlLgorICAgICAgICAgICAgSW50UmVjdCBy ZXNpemVSZWN0KHJlY3QueCwgcmVjdC55LCByZWN0LndpZHRoLCByZWN0LmhlaWdodCk7CisgICAg ICAgICAgICByZXNpemVSZWN0LmludGVyc2VjdChJbnRSZWN0KEludFBvaW50KCksIG1fbGF5ZXJS ZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVNpemUoKSkpOworICAgICAgICAgICAgZG9QaXhlbFJl YWRiYWNrVG9DYW52YXMoY2FudmFzLCByZXNpemVSZWN0KTsKKyAgICAgICAgfQorCisgICAgICAg IG1fbGF5ZXJSZW5kZXJlci0+cHJlc2VudCgpOyAvLyBEbyBmaW5hbCBkaXNwbGF5IGJ5IHN3YXBw aW5nIGJ1ZmZlcnMuCiAgICAgfQogI2VuZGlmCiB9CiAKKyNpZiBVU0UoQUNDRUxFUkFURURfQ09N UE9TSVRJTkcpCisjaWYgUExBVEZPUk0oU0tJQSkKK3N0YXRpYyBpbmxpbmUgdm9pZCBjbGVhclNr Qml0bWFwKGNvbnN0IFNrQml0bWFwJiBiaXRtYXApCit7CisgICAgYml0bWFwLmVyYXNlQ29sb3Io U2tDb2xvclNldEFSR0IoMCwgMCwgMCwgMCkpOworfQorCit2b2lkIFdlYlZpZXdJbXBsOjpkb1Bp eGVsUmVhZGJhY2tUb0NhbnZhcyhXZWJDYW52YXMqIGNhbnZhcywgSW50UmVjdCYgcmVjdCkKK3sK KyAgICBBU1NFUlQocmVjdC5yaWdodCgpIDw9IG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4 dHVyZVNpemUoKS53aWR0aCgpCisgICAgICAgICAgICYmIHJlY3QuYm90dG9tKCkgPD0gbV9sYXll clJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlU2l6ZSgpLmhlaWdodCgpKTsKKworICAgIHZvaWQq IHBpeGVscyA9IDA7CisgICAgY29uc3QgU2tCaXRtYXAgYml0bWFwID0gY2FudmFzLT5nZXREZXZp Y2UoKS0+YWNjZXNzQml0bWFwKGZhbHNlKTsKKyAgICBpZiAoYml0bWFwLmNvbmZpZygpID09IFNr Qml0bWFwOjprQVJHQl84ODg4X0NvbmZpZykgeworICAgICAgICBJbnRSZWN0IGJpdG1hcFJlY3Qo MCwgMCwgYml0bWFwLndpZHRoKCksIGJpdG1hcC5oZWlnaHQoKSk7CisKKyAgICAgICAgU2tBdXRv TG9ja1BpeGVscyBiaXRtYXBMb2NrKGJpdG1hcCk7CisKKyAgICAgICAgaWYgKHJlY3QgPT0gYml0 bWFwUmVjdCkgeworICAgICAgICAgICAgcGl4ZWxzID0gYml0bWFwLmdldFBpeGVscygpOworICAg ICAgICAgICAgbV9sYXllclJlbmRlcmVyLT5nZXRGcmFtZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHJl Y3QpOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgLy8gQ3JlYXRlIHRlbXAgYml0bWFw IG9mIGNvcnJlY3Qgc2l6ZSB0byBjb3B5IHBpeGVscyBpbnRvLgorICAgICAgICAgICAgc2tpYTo6 UGxhdGZvcm1DYW52YXMgY2FudmFzUmVzaXplOworICAgICAgICAgICAgaWYgKGNhbnZhc1Jlc2l6 ZS5pbml0aWFsaXplKHJlY3Qud2lkdGgoKSwgcmVjdC5oZWlnaHQoKSwgdHJ1ZSkpIHsKKyAgICAg ICAgICAgICAgICBTa0JpdG1hcCBiaXRtYXBSZXNpemUgPSBjYW52YXNSZXNpemUuZ2V0RGV2aWNl KCktPmFjY2Vzc0JpdG1hcChmYWxzZSk7CisgICAgICAgICAgICAgICAgcGl4ZWxzID0gYml0bWFw UmVzaXplLmdldFBpeGVscygpOworICAgICAgICAgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0 RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCByZWN0KTsKKyAgICAgICAgICAgICAgICBTa0lSZWN0 IHNyY1JlY3QocmVjdCk7CisgICAgICAgICAgICAgICAgU2tSZWN0IGRzdFJlY3QoYml0bWFwUmVj dCk7CisgICAgICAgICAgICAgICAgY2FudmFzLT5kcmF3Qml0bWFwUmVjdChiaXRtYXBSZXNpemUs ICZzcmNSZWN0LCBkc3RSZWN0LCAwKTsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAg ICAgICAgY2xlYXJTa0JpdG1hcChiaXRtYXApOworICAgICAgICAgICAgICAgIEFTU0VSVF9OT1Rf UkVBQ0hFRCgpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfSBlbHNlIHsKKyAgICAg ICAgY2xlYXJTa0JpdG1hcChiaXRtYXApOworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsK KyAgICB9Cit9CisKKyNlbGlmIFBMQVRGT1JNKENHKQorc3RhdGljIGlubGluZSB2b2lkIGNsZWFy Q0dCaXRtYXAoY29uc3QgQ0dDb250ZXh0UmVmJiBiaXRtYXApCit7CisgICAgQ0dDb250ZXh0Q2xl YXJSZWN0KGJpdG1hcCwKKyAgICAgICAgICAgICAgICAgICAgICAgQ0dSZWN0TWFrZSgwLCAwLCBD R0JpdG1hcENvbnRleHRHZXRXaWR0aChiaXRtYXApLCBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQo Yml0bWFwKSkpOworfQorCit2b2lkIFdlYlZpZXdJbXBsOjpkb1BpeGVsUmVhZGJhY2tUb0NhbnZh cyhXZWJDYW52YXMqIGNhbnZhcywgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBBU1NFUlQocmVjdC5y aWdodCgpIDw9IG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVNpemUoKS53aWR0aCgp CisgICAgICAgICAgICYmIHJlY3QuYm90dG9tKCkgPD0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5 ZXJUZXh0dXJlU2l6ZSgpLmhlaWdodCgpKTsKKworICAgIHZvaWQqIHBpeGVscyA9IDA7CisgICAg Q0dDb250ZXh0UmVmIGJpdG1hcCA9IHJlaW50ZXJwcmV0X2Nhc3Q8Q0dDb250ZXh0UmVmPihjYW52 YXMpOworICAgIEludFJlY3QgYml0bWFwUmVjdCgwLCAwLCBDR0JpdG1hcENvbnRleHRHZXRXaWR0 aChiaXRtYXApLCBDR0JpdG1hcENvbnRleHRHZXRIZWlnaHQoYml0bWFwKSk7CisgICAgaWYgKENH Qml0bWFwQ29udGV4dEdldFJvd0J5dGVzKGJpdG1hcCkgPT0gNCAqIGJpdG1hcFJlY3Qud2lkdGgo KSkgeworICAgICAgICBpZiAocmVjdCA9PSBiaXRtYXBSZWN0KSB7CisgICAgICAgICAgcGl4ZWxz ID0gQ0dCaXRtYXBDb250ZXh0R2V0RGF0YShiaXRtYXApOworICAgICAgICAgIG1fbGF5ZXJSZW5k ZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCByZWN0KTsKKyAgICAgICAgfSBlbHNl IHsKKyAgICAgICAgICAgIC8vIENyZWF0ZSB0ZW1wIGJpdG1hcCBvZiBzYW1lIHNpemUgYXMgcmVu ZGVyZWQgbGF5ZXIgdG8gY29weSBwaXhlbHMgaW50by4KKyAgICAgICAgICAgIENHQ29sb3JTcGFj ZVJlZiBjb2xvclNwYWNlID0gQ0dDb2xvclNwYWNlQ3JlYXRlRGV2aWNlUkdCKCk7CisgICAgICAg ICAgICBDR0NvbnRleHRSZWYgYml0bWFwUmVzaXplID0gQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKDAs IHJlY3Qud2lkdGgoKSwgcmVjdC5oZWlnaHQoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOCwgNCAqIHJlY3Qud2lkdGgoKSwg Y29sb3JTcGFjZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAga0NHSW1hZ2VBbHBoYVByZW11bHRpcGxpZWRMYXN0KTsKKyAgICAg ICAgICAgIGlmIChiaXRtYXBSZXNpemUpIHsKKyAgICAgICAgICAgICAgcGl4ZWxzID0gQ0dCaXRt YXBDb250ZXh0R2V0RGF0YShiaXRtYXBSZXNpemUpOworICAgICAgICAgICAgICBtX2xheWVyUmVu ZGVyZXItPmdldEZyYW1lYnVmZmVyUGl4ZWxzKHBpeGVscywgcmVjdCk7CisKKyAgICAgICAgICAg ICAgLy8gQ29weSBiaXRtYXAgYmFjayB0byBpbnB1dCBiaXRtYXAuIFRoZSBpbWFnZSBpcyBpbnZl cnRlZCBhY2NvcmRpbmcgdG8gQ0csCisgICAgICAgICAgICAgIC8vIHNvIHNldCB1cCB0aGUgYXBw cm9wcmlhdGUgdHJhbnNmb3JtIHRvIGludmVydCB2ZXJ0aWNhbCBheGlzIGFuZCBtb3ZlIG9yaWdp bgorICAgICAgICAgICAgICAvLyB0byBib3R0b20gbGVmdC4KKyAgICAgICAgICAgICAgQ0dDb250 ZXh0U2F2ZUdTdGF0ZShiaXRtYXApOworICAgICAgICAgICAgICBDR0NvbnRleHRUcmFuc2xhdGVD VE0oYml0bWFwLCAwLCBiaXRtYXBSZWN0LmhlaWdodCgpKTsKKyAgICAgICAgICAgICAgQ0dDb250 ZXh0U2NhbGVDVE0oYml0bWFwLCAxLjAsIC0xLjApOworICAgICAgICAgICAgICBDR0NvbnRleHRE cmF3SW1hZ2UoYml0bWFwLCBiaXRtYXBSZWN0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlSW1hZ2UoYml0bWFwUmVzaXplKSk7CisgICAgICAg ICAgICAgIENHQ29udGV4dFJlc3RvcmVHU3RhdGUoYml0bWFwKTsKKyAgICAgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICAgICAgY2xlYXJDR0JpdG1hcChiaXRtYXApOworICAgICAgICAgICAg ICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAg fSBlbHNlIHsKKyAgICAgICAgY2xlYXJDR0JpdG1hcChiaXRtYXApOworICAgICAgICBBU1NFUlRf Tk9UX1JFQUNIRUQoKTsKKyAgICB9Cit9CisjZWxzZQorI2Vycm9yIE11c3QgcG9ydCB0byB5b3Vy IHBsYXRmb3JtLgorI2VuZGlmCisKKyNlbmRpZgorCiAvLyBGSVhNRTogbV9jdXJyZW50SW5wdXRF dmVudCBzaG91bGQgYmUgcmVtb3ZlZCBvbmNlIENocm9tZUNsaWVudDo6c2hvdygpIGNhbgogLy8g Z2V0IHRoZSBjdXJyZW50LWV2ZW50IGluZm9ybWF0aW9uIGZyb20gV2ViQ29yZS4KIGNvbnN0IFdl YklucHV0RXZlbnQqIFdlYlZpZXdJbXBsOjptX2N1cnJlbnRJbnB1dEV2ZW50ID0gMDsKZGlmZiAt LWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaCBiL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViVmlld0ltcGwuaAppbmRleCBjMjk2MTIxMjNmNDUxNGM5NGRkN2Q5NzBjNzMxMTRh NGJlZWVjMzU1Li42N2NjZTAxNjNlMGE0ZjU1NTFhMmU2MDhkZWUyNjMwNWI1YzU1NzY2IDEwMDY0 NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKKysrIGIvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBAIC00NSw2ICs0NSw3IEBACiAjaW5jbHVkZSAiRWRp dG9yQ2xpZW50SW1wbC5oIgogI2luY2x1ZGUgIkdyYXBoaWNzTGF5ZXIuaCIKICNpbmNsdWRlICJJ bnNwZWN0b3JDbGllbnRJbXBsLmgiCisjaW5jbHVkZSA8SW50UmVjdC5oPgogI2luY2x1ZGUgIkxh eWVyUmVuZGVyZXJDaHJvbWl1bS5oIgogI2luY2x1ZGUgIk5vdGlmaWNhdGlvblByZXNlbnRlcklt cGwuaCIKICNpbmNsdWRlICJTcGVlY2hJbnB1dENsaWVudEltcGwuaCIKQEAgLTM4Niw2ICszODcs NyBAQCBwcml2YXRlOgogI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKICAgICB2b2lk IHNldElzQWNjZWxlcmF0ZWRDb21wb3NpdGluZ0FjdGl2ZShib29sKTsKICAgICB2b2lkIHVwZGF0 ZVJvb3RMYXllckNvbnRlbnRzKGNvbnN0IFdlYlJlY3QmKTsKKyAgICB2b2lkIGRvUGl4ZWxSZWFk YmFja1RvQ2FudmFzKFdlYkNhbnZhcyosIFdlYkNvcmU6OkludFJlY3QmKTsKICNlbmRpZgogCiAg ICAgV2ViVmlld0NsaWVudCogbV9jbGllbnQ7Cg== 66521 2010-09-03 10:59:34 -0700 2010-09-07 13:15:02 -0700 Patch bug-44127-20100903135939.patch text/plain 12180 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MGVmZDA0YTYwMzQ0ZDk1ZjU5NDBhNGFjNDI2YzJhODM0NmM3MGU4Zi4uOGM5NTE4ZDI3MTdkZmI5 NTgzODM4N2NjYmRlZTIwYmJjNDg4MzQ3NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOS0wMyAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKyAgICAgICAgQWRkcyBw aXhlbC1yZWFkYmFjayBmb3IgR1BVIGNvbXBvc2l0ZWQgcGFnZXMgdG8gYWxsb3cgZm9yIHRodW1i bmFpbGluZywKKyAgICAgICAgcHJpbnRpbmcgYW5kIG90aGVyIHNlcnZpY2VzIHRvIHdvcmsgd2l0 aCBHUFUgcmVuZGVyZWQgcGFnZXMuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVu ZGVyZXJDaHJvbWl1bTo6cHJlc2VudCk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVy Q2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaDoKKyAgICAgICAgKFdlYkNvcmU6 OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6cm9vdExheWVyVGV4dHVyZVNpemUpOgorCiAyMDEwLTA5 LTAzICBaYWhlZXIgQWhtYWQgPHphaGVlci5tb3RAZ21haWwuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IERhcmluIEFkbGVyLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCmluZGV4IDUwMzM4ZDJk NWY3MzI0ZTVhMTE5YzUwOTE5MGRmZWY4Njk4YjE3NjkuLjJkZWIyMjYzMDUwMTgwMDVjM2ViZDg5 MmU2YTUyYjc5MjVjMDAwNmYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKQEAgLTM5LDYgKzM5 LDcgQEAKICNpbmNsdWRlICJHTEVTMkNvbnRleHQuaCIKICNpbmNsdWRlICJMYXllckNocm9taXVt LmgiCiAjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKKyNpbmNsdWRlIDx3dGYvT3duQXJyYXlQ dHIuaD4KICNpZiBQTEFURk9STShTS0lBKQogI2luY2x1ZGUgIk5hdGl2ZUltYWdlU2tpYS5oIgog I2luY2x1ZGUgIlBsYXRmb3JtQ29udGV4dFNraWEuaCIKQEAgLTMyMSwxMSArMzIyLDQyIEBAIHZv aWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKGNvbnN0IEludFJlY3QmIHVwZGF0 ZVJlY3QsIGNvbnN0IEludFJlY3QmCiAKICAgICBHTEMoZ2xEaXNhYmxlKEdMX1NDSVNTT1JfVEVT VCkpOwogCisgICAgZ2xGbHVzaCgpOworfQorCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6 cHJlc2VudCgpCit7CiAgICAgbV9nbGVzMkNvbnRleHQtPnN3YXBCdWZmZXJzKCk7CiAKICAgICBt X25lZWRzRGlzcGxheSA9IGZhbHNlOwogfQogCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6 Z2V0RnJhbWVidWZmZXJQaXhlbHModm9pZCAqcGl4ZWxzLCBjb25zdCBJbnRSZWN0JiByZWN0KQor eworICAgIEFTU0VSVChyZWN0LnJpZ2h0KCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUoKS53aWR0 aCgpCisgICAgICAgICAgICYmIHJlY3QuYm90dG9tKCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUo KS5oZWlnaHQoKSk7CisKKyAgICBpZiAoIXBpeGVscykKKyAgICAgICAgcmV0dXJuOworCisgICAg bWFrZUNvbnRleHRDdXJyZW50KCk7CisKKyAgICBHTEMoZ2xSZWFkUGl4ZWxzKHJlY3QueCgpLCBy ZWN0LnkoKSwgcmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpLAorICAgICAgICAgICAgICAgICAg ICAgR0xfUkdCQSwgR0xfVU5TSUdORURfQllURSwgcGl4ZWxzKSk7CisKKyAgICAvLyBGbGlwIHBp eGVscyB2ZXJ0aWNhbGx5LgorICAgIGNvbnN0IGludCByb3dCeXRlcyA9IDQgKiByZWN0LndpZHRo KCk7CisgICAgT3duQXJyYXlQdHI8dW5zaWduZWQgY2hhcj4gbGluZVRlbXAobmV3IHVuc2lnbmVk IGNoYXJbcm93Qnl0ZXNdKTsKKyAgICBmb3IgKGludCByb3cxID0gMCwgcm93MiA9IHJlY3QuaGVp Z2h0KCkgLSAxOyByb3cxIDwgcmVjdC5oZWlnaHQoKSAvIDI7ICsrcm93MSwgLS1yb3cyKSB7Cisg ICAgICAgIHVuc2lnbmVkIGNoYXIqIHB0cjEgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4o cGl4ZWxzKSArIHJvdzEgKiByb3dCeXRlczsKKyAgICAgICAgdW5zaWduZWQgY2hhciogcHRyMiA9 IHN0YXRpY19jYXN0PHVuc2lnbmVkIGNoYXIqPihwaXhlbHMpICsgcm93MiAqIHJvd0J5dGVzOwor CisgICAgICAgIG1lbWNweShsaW5lVGVtcC5nZXQoKSwgcHRyMSwgcm93Qnl0ZXMpOworICAgICAg ICBtZW1jcHkocHRyMSwgcHRyMiwgcm93Qnl0ZXMpOworICAgICAgICBtZW1jcHkocHRyMiwgbGlu ZVRlbXAuZ2V0KCksIHJvd0J5dGVzKTsKKyAgICB9Cit9CisKIC8vIEZJWE1FOiBUaGlzIG1ldGhv ZCBzaG91bGQgZXZlbnR1YWxseSBiZSByZXBsYWNlZCBieSBhIHByb3BlciB0ZXh0dXJlIG1hbmFn ZXIuCiB1bnNpZ25lZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmNyZWF0ZUxheWVyVGV4dHVyZSgp CiB7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVy UmVuZGVyZXJDaHJvbWl1bS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXllclJlbmRlcmVyQ2hyb21pdW0uaAppbmRleCA4ZjQ0YWZlYmQwYTJjN2I0NzVkMDRiYTQ4NzIz ZjFjZGM1NDU1MDkxLi5mZmU0MTQyM2Q1M2UzZjU0MGU3MTAyMzNmYWYyYTBmODE1NjJjZTU3IDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVy ZXJDaHJvbWl1bS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5 ZXJSZW5kZXJlckNocm9taXVtLmgKQEAgLTY0LDYgKzY0LDcgQEAgcHVibGljOgogICAgIC8vIFVw ZGF0ZXMgdGhlIGNvbnRlbnRzIG9mIHRoZSByb290IGxheWVyIHRoYXQgZmFsbCBpbnNpZGUgdGhl IHVwZGF0ZVJlY3QgYW5kIHJlY29tcG9zaXRlcwogICAgIC8vIGFsbCB0aGUgbGF5ZXJzLgogICAg IHZvaWQgZHJhd0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0 JiB2aXNpYmxlUmVjdCwgY29uc3QgSW50UmVjdCYgY29udGVudFJlY3QsIGNvbnN0IEludFBvaW50 JiBzY3JvbGxQb3NpdGlvbik7CisgICAgdm9pZCBwcmVzZW50KCk7IC8vIFBlcmZvcm0gYnVmZmVy IHN3YXAgdG8gcHJlc2VudCByZW5kZXJlZCBidWZmZXIuCiAKICAgICB2b2lkIHNldFJvb3RMYXll cihQYXNzUmVmUHRyPExheWVyQ2hyb21pdW0+IGxheWVyKSB7IG1fcm9vdExheWVyID0gbGF5ZXI7 IH0KICAgICBMYXllckNocm9taXVtKiByb290TGF5ZXIoKSB7IHJldHVybiBtX3Jvb3RMYXllci5n ZXQoKTsgfQpAQCAtOTAsNiArOTEsOSBAQCBwdWJsaWM6CiAgICAgY29uc3QgQ29udGVudExheWVy Q2hyb21pdW06OlNoYXJlZFZhbHVlcyogY29udGVudExheWVyU2hhcmVkVmFsdWVzKCkgY29uc3Qg eyByZXR1cm4gbV9jb250ZW50TGF5ZXJTaGFyZWRWYWx1ZXMuZ2V0KCk7IH0KICAgICBjb25zdCBD YW52YXNMYXllckNocm9taXVtOjpTaGFyZWRWYWx1ZXMqIGNhbnZhc0xheWVyU2hhcmVkVmFsdWVz KCkgY29uc3QgeyByZXR1cm4gbV9jYW52YXNMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsgfQogCisg ICAgSW50U2l6ZSByb290TGF5ZXJUZXh0dXJlU2l6ZSgpIGNvbnN0IHsgcmV0dXJuIEludFNpemUo bV9yb290TGF5ZXJUZXh0dXJlV2lkdGgsIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCk7IH0KKyAg ICB2b2lkIGdldEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgSW50UmVjdCYg cmVjdCk7CisKIHByaXZhdGU6CiAgICAgdm9pZCB1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5ZXJD aHJvbWl1bSogbGF5ZXIsIGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0cml4JiBwYXJlbnRNYXRyaXgs IGZsb2F0IG9wYWNpdHkpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9n IGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCA5ZTAwMzAyZWE5MzgwMWU0NmJmYjc3 ZGNiNjIzNWIxZWVkYzAwZDc1Li5jMzU3NzM2MDgwNjU1M2MzMzdkNGRkYjRhOTdhNDZkYjJmYzdh MjFkIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wOS0wMyAgVy4gSmFtZXMg TWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5vdCBnZW5l cmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBNb2RpZmllZCBXZWJWaWV3SW1w bDo6cGFpbnQoKSB0byBkZXRlY3Qgbm9uLW51bGwgY2FudmFzIHBvaW50ZXJzIHdoZW4KKyAgICAg ICAgYWNjZWxlcmF0ZWQgY29tcG9zaXRpbmcgaXMgYWN0aXZlLCBhbmQgaW5zdGVhZCBmaWxscyB0 aGUgcGl4ZWwgYnVmZmVyCisgICAgICAgIGZyb20gdGhlIEdQVSBmcmFtZWJ1ZmZlci4gSW5jbHVk ZXMgcmUtc2NhbGluZyBzdXBwb3J0IHdoZW4gcHJvdmlkZWQKKyAgICAgICAgY2FudmFzIGRvZXMg bm90IG1hdGNoIHNpemUgb2YgY3VycmVudCByZW5kZXIgbGF5ZXIuIExpbWl0cyBwaXhlbAorICAg ICAgICByZWFkYmFjayB0byByZWN0IHBhc3NlZCB0byBwYWludCgpLCBjbGlwcGVkIGJ5IHNpemUg b2Ygcm9vdExheWVyVGV4dHVyZS4KKworICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5jcHA6Cisg ICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBsOjpwYWludCk6CisgICAgICAgIChXZWJLaXQ6OmNs ZWFyU2tCaXRtYXApOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6ZG9QaXhlbFJlYWRi YWNrVG9DYW52YXMpOgorICAgICAgICAoV2ViS2l0OjpjbGVhckNHQml0bWFwKToKKyAgICAgICAg KiBzcmMvV2ViVmlld0ltcGwuaDoKKwogMjAxMC0wOC0zMSAgSmVyZW15IE9ybG93ICA8am9ybG93 QGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBTdGV2ZSBCbG9jay4KZGlmZiAt LWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKaW5kZXggNGIxMjlkNjk0YjFmMTEyZjI3YjIxYWU3MjRk YjY3YTY4YTc0ZTAyYS4uOWFkM2EzMTE0NzI1ZDdlYzFjMGRiMTJhY2VhMzJlMmE0NzYwMWI4NSAx MDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTY0LDcgKzY0LDYgQEAKICNpbmNs dWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJJbWFnZS5oIgogI2luY2x1ZGUgIkluc3BlY3Rv ckNvbnRyb2xsZXIuaCIKLSNpbmNsdWRlICJJbnRSZWN0LmgiCiAjaW5jbHVkZSAiS2V5Ym9hcmRD b2Rlcy5oIgogI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJNSU1FVHlwZVJl Z2lzdHJ5LmgiCkBAIC0xMTUsNiArMTE0LDEwIEBACiAjaW5jbHVkZSAiV2ViVmlld0NsaWVudC5o IgogI2luY2x1ZGUgInd0Zi9Pd25QdHIuaCIKIAorI2lmIFBMQVRGT1JNKENHKQorI2luY2x1ZGUg PENvcmVHcmFwaGljcy9DR0NvbnRleHQuaD4KKyNlbmRpZgorCiAjaWYgT1MoV0lORE9XUykKICNp bmNsdWRlICJSZW5kZXJUaGVtZUNocm9taXVtV2luLmgiCiAjZWxzZQpAQCAtOTY4LDEwICs5NzEs MTE3IEBAIHZvaWQgV2ViVmlld0ltcGw6OnBhaW50KFdlYkNhbnZhcyogY2FudmFzLCBjb25zdCBX ZWJSZWN0JiByZWN0KQogCiAgICAgICAgIC8vIEFzayB0aGUgbGF5ZXIgY29tcG9zaXRvciB0byBy ZWRyYXcgYWxsIHRoZSBsYXllcnMuCiAgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+ZHJhd0xheWVy cyhyZWN0LCB2aXNpYmxlUmVjdCwgY29udGVudFJlY3QsIEludFBvaW50KHZpZXctPnNjcm9sbFgo KSwgdmlldy0+c2Nyb2xsWSgpKSk7CisKKyAgICAgICAgLy8gSWYgYSBjYW52YXMgd2FzIHBhc3Nl ZCBpbiwgd2UgdXNlIGl0IHRvIGdyYWIgYSBjb3B5IG9mIHRoZQorICAgICAgICAvLyBmcmVzaGx5 LXJlbmRlcmVkIHBpeGVscy4KKyAgICAgICAgaWYgKGNhbnZhcykgeworICAgICAgICAgICAgLy8g Q2xpcCByZWN0IHRvIHRoZSBjb25maW5lcyBvZiB0aGUgcm9vdExheWVyVGV4dHVyZS4KKyAgICAg ICAgICAgIEludFJlY3QgcmVzaXplUmVjdChyZWN0LngsIHJlY3QueSwgcmVjdC53aWR0aCwgcmVj dC5oZWlnaHQpOworICAgICAgICAgICAgcmVzaXplUmVjdC5pbnRlcnNlY3QoSW50UmVjdChJbnRQ b2ludCgpLCBtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVTaXplKCkpKTsKKyAgICAg ICAgICAgIGRvUGl4ZWxSZWFkYmFja1RvQ2FudmFzKGNhbnZhcywgcmVzaXplUmVjdCk7CisgICAg ICAgIH0KKworICAgICAgICBtX2xheWVyUmVuZGVyZXItPnByZXNlbnQoKTsgLy8gRG8gZmluYWwg ZGlzcGxheSBieSBzd2FwcGluZyBidWZmZXJzLgogICAgIH0KICNlbmRpZgogfQogCisjaWYgVVNF KEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQorI2lmIFBMQVRGT1JNKFNLSUEpCitzdGF0aWMgaW5s aW5lIHZvaWQgY2xlYXJTa0JpdG1hcChjb25zdCBTa0JpdG1hcCYgYml0bWFwKQoreworICAgIGJp dG1hcC5lcmFzZUNvbG9yKFNrQ29sb3JTZXRBUkdCKDAsIDAsIDAsIDApKTsKK30KKwordm9pZCBX ZWJWaWV3SW1wbDo6ZG9QaXhlbFJlYWRiYWNrVG9DYW52YXMoV2ViQ2FudmFzKiBjYW52YXMsIGNv bnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgQVNTRVJUKHJlY3QucmlnaHQoKSA8PSBtX2xheWVy UmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVTaXplKCkud2lkdGgoKQorICAgICAgICAgICAmJiBy ZWN0LmJvdHRvbSgpIDw9IG1fbGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVNpemUoKS5o ZWlnaHQoKSk7CisKKyAgICB2b2lkKiBwaXhlbHMgPSAwOworICAgIGNvbnN0IFNrQml0bWFwIGJp dG1hcCA9IGNhbnZhcy0+Z2V0RGV2aWNlKCktPmFjY2Vzc0JpdG1hcChmYWxzZSk7CisgICAgaWYg KGJpdG1hcC5jb25maWcoKSA9PSBTa0JpdG1hcDo6a0FSR0JfODg4OF9Db25maWcpIHsKKyAgICAg ICAgSW50UmVjdCBiaXRtYXBSZWN0KDAsIDAsIGJpdG1hcC53aWR0aCgpLCBiaXRtYXAuaGVpZ2h0 KCkpOworCisgICAgICAgIGlmIChyZWN0ID09IGJpdG1hcFJlY3QpIHsKKyAgICAgICAgICAgIFNr QXV0b0xvY2tQaXhlbHMgYml0bWFwTG9jayhiaXRtYXApOworICAgICAgICAgICAgcGl4ZWxzID0g Yml0bWFwLmdldFBpeGVscygpOworICAgICAgICAgICAgbV9sYXllclJlbmRlcmVyLT5nZXRGcmFt ZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHJlY3QpOworICAgICAgICB9IGVsc2UgeworICAgICAgICAg ICAgLy8gQ3JlYXRlIHRlbXAgYml0bWFwIG9mIGNvcnJlY3Qgc2l6ZSB0byBjb3B5IHBpeGVscyBp bnRvLgorICAgICAgICAgICAgc2tpYTo6UGxhdGZvcm1DYW52YXMgY2FudmFzUmVzaXplOworICAg ICAgICAgICAgaWYgKGNhbnZhc1Jlc2l6ZS5pbml0aWFsaXplKHJlY3Qud2lkdGgoKSwgcmVjdC5o ZWlnaHQoKSwgdHJ1ZSkpIHsKKyAgICAgICAgICAgICAgICBTa0JpdG1hcCBiaXRtYXBSZXNpemUg PSBjYW52YXNSZXNpemUuZ2V0RGV2aWNlKCktPmFjY2Vzc0JpdG1hcChmYWxzZSk7CisgICAgICAg ICAgICAgICAgcGl4ZWxzID0gYml0bWFwUmVzaXplLmdldFBpeGVscygpOworICAgICAgICAgICAg ICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCByZWN0KTsK KyAgICAgICAgICAgICAgICBTa0lSZWN0IHNyY1JlY3QoSW50UmVjdChJbnRQb2ludCgpLCByZWN0 LnNpemUoKSkpOworICAgICAgICAgICAgICAgIFNrUmVjdCBkc3RSZWN0KGJpdG1hcFJlY3QpOwor ICAgICAgICAgICAgICAgIGNhbnZhcy0+ZHJhd0JpdG1hcFJlY3QoYml0bWFwUmVzaXplLCAmc3Jj UmVjdCwgZHN0UmVjdCwgMCk7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAg IGNsZWFyU2tCaXRtYXAoYml0bWFwKTsKKyAgICAgICAgICAgICAgICBBU1NFUlRfTk9UX1JFQUNI RUQoKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0gZWxzZSB7CisgICAgICAgIGNs ZWFyU2tCaXRtYXAoYml0bWFwKTsKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAg fQorfQorCisjZWxpZiBQTEFURk9STShDRykKK3N0YXRpYyBpbmxpbmUgdm9pZCBjbGVhckNHQml0 bWFwKGNvbnN0IENHQ29udGV4dFJlZiYgYml0bWFwKQoreworICAgIENHQ29udGV4dENsZWFyUmVj dChiaXRtYXAsCisgICAgICAgICAgICAgICAgICAgICAgIENHUmVjdE1ha2UoMCwgMCwgQ0dCaXRt YXBDb250ZXh0R2V0V2lkdGgoYml0bWFwKSwgQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1h cCkpKTsKK30KKwordm9pZCBXZWJWaWV3SW1wbDo6ZG9QaXhlbFJlYWRiYWNrVG9DYW52YXMoV2Vi Q2FudmFzKiBjYW52YXMsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgQVNTRVJUKHJlY3Qu cmlnaHQoKSA8PSBtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVTaXplKCkud2lkdGgo KQorICAgICAgICAgICAmJiByZWN0LmJvdHRvbSgpIDw9IG1fbGF5ZXJSZW5kZXJlci0+cm9vdExh eWVyVGV4dHVyZVNpemUoKS5oZWlnaHQoKSk7CisKKyAgICB2b2lkKiBwaXhlbHMgPSAwOworICAg IENHQ29udGV4dFJlZiBiaXRtYXAgPSByZWludGVycHJldF9jYXN0PENHQ29udGV4dFJlZj4oY2Fu dmFzKTsKKyAgICBJbnRSZWN0IGJpdG1hcFJlY3QoMCwgMCwgQ0dCaXRtYXBDb250ZXh0R2V0V2lk dGgoYml0bWFwKSwgQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1hcCkpOworICAgIGlmIChD R0JpdG1hcENvbnRleHRHZXRCeXRlc1BlclJvdyhiaXRtYXApID09IDR1ICogYml0bWFwUmVjdC53 aWR0aCgpKSB7CisgICAgICAgIGlmIChyZWN0ID09IGJpdG1hcFJlY3QpIHsKKyAgICAgICAgICBw aXhlbHMgPSBDR0JpdG1hcENvbnRleHRHZXREYXRhKGJpdG1hcCk7CisgICAgICAgICAgbV9sYXll clJlbmRlcmVyLT5nZXRGcmFtZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHJlY3QpOworICAgICAgICB9 IGVsc2UgeworICAgICAgICAgICAgLy8gQ3JlYXRlIHRlbXAgYml0bWFwIG9mIHNhbWUgc2l6ZSBh cyByZW5kZXJlZCBsYXllciB0byBjb3B5IHBpeGVscyBpbnRvLgorICAgICAgICAgICAgQ0dDb2xv clNwYWNlUmVmIGNvbG9yU3BhY2UgPSBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VSR0IoKTsKKyAg ICAgICAgICAgIENHQ29udGV4dFJlZiBiaXRtYXBSZXNpemUgPSBDR0JpdG1hcENvbnRleHRDcmVh dGUoMCwgcmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA4LCA0ICogcmVjdC53aWR0 aCgpLCBjb2xvclNwYWNlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGllZExhc3QpOwor ICAgICAgICAgICAgaWYgKGJpdG1hcFJlc2l6ZSkgeworICAgICAgICAgICAgICBwaXhlbHMgPSBD R0JpdG1hcENvbnRleHRHZXREYXRhKGJpdG1hcFJlc2l6ZSk7CisgICAgICAgICAgICAgIG1fbGF5 ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCByZWN0KTsKKworICAgICAg ICAgICAgICAvLyBDb3B5IGJpdG1hcCBiYWNrIHRvIGlucHV0IGJpdG1hcC4gVGhlIGltYWdlIGlz IGludmVydGVkIGFjY29yZGluZyB0byBDRywKKyAgICAgICAgICAgICAgLy8gc28gc2V0IHVwIHRo ZSBhcHByb3ByaWF0ZSB0cmFuc2Zvcm0gdG8gaW52ZXJ0IHZlcnRpY2FsIGF4aXMgYW5kIG1vdmUg b3JpZ2luCisgICAgICAgICAgICAgIC8vIHRvIGJvdHRvbSBsZWZ0LgorICAgICAgICAgICAgICBD R0NvbnRleHRTYXZlR1N0YXRlKGJpdG1hcCk7CisgICAgICAgICAgICAgIENHQ29udGV4dFRyYW5z bGF0ZUNUTShiaXRtYXAsIDAsIGJpdG1hcFJlY3QuaGVpZ2h0KCkpOworICAgICAgICAgICAgICBD R0NvbnRleHRTY2FsZUNUTShiaXRtYXAsIDEuMCwgLTEuMCk7CisgICAgICAgICAgICAgIENHQ29u dGV4dERyYXdJbWFnZShiaXRtYXAsIGJpdG1hcFJlY3QsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBDR0JpdG1hcENvbnRleHRDcmVhdGVJbWFnZShiaXRtYXBSZXNpemUpKTsKKyAg ICAgICAgICAgICAgQ0dDb250ZXh0UmVzdG9yZUdTdGF0ZShiaXRtYXApOworICAgICAgICAgICAg fSBlbHNlIHsKKyAgICAgICAgICAgICAgICBjbGVhckNHQml0bWFwKGJpdG1hcCk7CisgICAgICAg ICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0K KyAgICB9IGVsc2UgeworICAgICAgICBjbGVhckNHQml0bWFwKGJpdG1hcCk7CisgICAgICAgIEFT U0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIH0KK30KKyNlbHNlCisjZXJyb3IgTXVzdCBwb3J0IHRv IHlvdXIgcGxhdGZvcm0uCisjZW5kaWYKKworI2VuZGlmCisKIC8vIEZJWE1FOiBtX2N1cnJlbnRJ bnB1dEV2ZW50IHNob3VsZCBiZSByZW1vdmVkIG9uY2UgQ2hyb21lQ2xpZW50OjpzaG93KCkgY2Fu CiAvLyBnZXQgdGhlIGN1cnJlbnQtZXZlbnQgaW5mb3JtYXRpb24gZnJvbSBXZWJDb3JlLgogY29u c3QgV2ViSW5wdXRFdmVudCogV2ViVmlld0ltcGw6Om1fY3VycmVudElucHV0RXZlbnQgPSAwOwpk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oIGIvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCmluZGV4IGMyOTYxMjEyM2Y0NTE0Yzk0ZGQ3ZDk3MGM3 MzExNGE0YmVlZWMzNTUuLmQyMDAzYTRlYTYxZDk1OTBlZmZhNjI4M2ZhY2IzZmI3ODc2NzYzZTEg MTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAorKysgYi9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKQEAgLTQ1LDYgKzQ1LDcgQEAKICNpbmNsdWRl ICJFZGl0b3JDbGllbnRJbXBsLmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NMYXllci5oIgogI2luY2x1 ZGUgIkluc3BlY3RvckNsaWVudEltcGwuaCIKKyNpbmNsdWRlIDxJbnRSZWN0Lmg+CiAjaW5jbHVk ZSAiTGF5ZXJSZW5kZXJlckNocm9taXVtLmgiCiAjaW5jbHVkZSAiTm90aWZpY2F0aW9uUHJlc2Vu dGVySW1wbC5oIgogI2luY2x1ZGUgIlNwZWVjaElucHV0Q2xpZW50SW1wbC5oIgpAQCAtMzg2LDYg KzM4Nyw3IEBAIHByaXZhdGU6CiAjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQogICAg IHZvaWQgc2V0SXNBY2NlbGVyYXRlZENvbXBvc2l0aW5nQWN0aXZlKGJvb2wpOwogICAgIHZvaWQg dXBkYXRlUm9vdExheWVyQ29udGVudHMoY29uc3QgV2ViUmVjdCYpOworICAgIHZvaWQgZG9QaXhl bFJlYWRiYWNrVG9DYW52YXMoV2ViQ2FudmFzKiwgY29uc3QgV2ViQ29yZTo6SW50UmVjdCYpOwog I2VuZGlmCiAKICAgICBXZWJWaWV3Q2xpZW50KiBtX2NsaWVudDsK 66755 2010-09-07 13:15:08 -0700 2010-09-08 10:34:06 -0700 Patch bug-44127-20100907161534.patch text/plain 12073 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MGVmZDA0YTYwMzQ0ZDk1ZjU5NDBhNGFjNDI2YzJhODM0NmM3MGU4Zi4uOGM5NTE4ZDI3MTdkZmI5 NTgzODM4N2NjYmRlZTIwYmJjNDg4MzQ3NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOS0wMyAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKyAgICAgICAgQWRkcyBw aXhlbC1yZWFkYmFjayBmb3IgR1BVIGNvbXBvc2l0ZWQgcGFnZXMgdG8gYWxsb3cgZm9yIHRodW1i bmFpbGluZywKKyAgICAgICAgcHJpbnRpbmcgYW5kIG90aGVyIHNlcnZpY2VzIHRvIHdvcmsgd2l0 aCBHUFUgcmVuZGVyZWQgcGFnZXMuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVu ZGVyZXJDaHJvbWl1bTo6cHJlc2VudCk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVy Q2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaDoKKyAgICAgICAgKFdlYkNvcmU6 OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6cm9vdExheWVyVGV4dHVyZVNpemUpOgorCiAyMDEwLTA5 LTAzICBaYWhlZXIgQWhtYWQgPHphaGVlci5tb3RAZ21haWwuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IERhcmluIEFkbGVyLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCmluZGV4IDUwMzM4ZDJk NWY3MzI0ZTVhMTE5YzUwOTE5MGRmZWY4Njk4YjE3NjkuLmQxMmUwZGQxY2FmYWMyY2ZjNjQ3OTJl NjY1ODQ4YjhhYmNmNTk2Y2IgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKQEAgLTM5LDYgKzM5 LDcgQEAKICNpbmNsdWRlICJHTEVTMkNvbnRleHQuaCIKICNpbmNsdWRlICJMYXllckNocm9taXVt LmgiCiAjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKKyNpbmNsdWRlIDx3dGYvT3duQXJyYXlQ dHIuaD4KICNpZiBQTEFURk9STShTS0lBKQogI2luY2x1ZGUgIk5hdGl2ZUltYWdlU2tpYS5oIgog I2luY2x1ZGUgIlBsYXRmb3JtQ29udGV4dFNraWEuaCIKQEAgLTMyMSwxMSArMzIyLDQ0IEBAIHZv aWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKGNvbnN0IEludFJlY3QmIHVwZGF0 ZVJlY3QsIGNvbnN0IEludFJlY3QmCiAKICAgICBHTEMoZ2xEaXNhYmxlKEdMX1NDSVNTT1JfVEVT VCkpOwogCisgICAgZ2xGbHVzaCgpOworfQorCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6 cHJlc2VudCgpCit7CiAgICAgbV9nbGVzMkNvbnRleHQtPnN3YXBCdWZmZXJzKCk7CiAKICAgICBt X25lZWRzRGlzcGxheSA9IGZhbHNlOwogfQogCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6 Z2V0RnJhbWVidWZmZXJQaXhlbHModm9pZCAqcGl4ZWxzLCBjb25zdCBJbnRSZWN0JiByZWN0KQor eworICAgIEFTU0VSVChyZWN0LnJpZ2h0KCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUoKS53aWR0 aCgpCisgICAgICAgICAgICYmIHJlY3QuYm90dG9tKCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUo KS5oZWlnaHQoKSk7CisKKyAgICBpZiAoIXBpeGVscykKKyAgICAgICAgcmV0dXJuOworCisgICAg bWFrZUNvbnRleHRDdXJyZW50KCk7CisKKyAgICBHTEMoZ2xSZWFkUGl4ZWxzKHJlY3QueCgpLCBy ZWN0LnkoKSwgcmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpLAorICAgICAgICAgICAgICAgICAg ICAgR0xfUkdCQSwgR0xfVU5TSUdORURfQllURSwgcGl4ZWxzKSk7CisKKyNpZiBQTEFURk9STShT S0lBKQorICAgIC8vIEZsaXAgcGl4ZWxzIHZlcnRpY2FsbHkuCisgICAgY29uc3QgaW50IHJvd0J5 dGVzID0gNCAqIHJlY3Qud2lkdGgoKTsKKyAgICBPd25BcnJheVB0cjx1bnNpZ25lZCBjaGFyPiBs aW5lVGVtcChuZXcgdW5zaWduZWQgY2hhcltyb3dCeXRlc10pOworICAgIGZvciAoaW50IHJvdzEg PSAwLCByb3cyID0gcmVjdC5oZWlnaHQoKSAtIDE7IHJvdzEgPCByZWN0LmhlaWdodCgpIC8gMjsg Kytyb3cxLCAtLXJvdzIpIHsKKyAgICAgICAgdW5zaWduZWQgY2hhciogcHRyMSA9IHN0YXRpY19j YXN0PHVuc2lnbmVkIGNoYXIqPihwaXhlbHMpICsgcm93MSAqIHJvd0J5dGVzOworICAgICAgICB1 bnNpZ25lZCBjaGFyKiBwdHIyID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgY2hhcio+KHBpeGVscykg KyByb3cyICogcm93Qnl0ZXM7CisKKyAgICAgICAgbWVtY3B5KGxpbmVUZW1wLmdldCgpLCBwdHIx LCByb3dCeXRlcyk7CisgICAgICAgIG1lbWNweShwdHIxLCBwdHIyLCByb3dCeXRlcyk7CisgICAg ICAgIG1lbWNweShwdHIyLCBsaW5lVGVtcC5nZXQoKSwgcm93Qnl0ZXMpOworICAgIH0KKyNlbmRp ZgorfQorCiAvLyBGSVhNRTogVGhpcyBtZXRob2Qgc2hvdWxkIGV2ZW50dWFsbHkgYmUgcmVwbGFj ZWQgYnkgYSBwcm9wZXIgdGV4dHVyZSBtYW5hZ2VyLgogdW5zaWduZWQgTGF5ZXJSZW5kZXJlckNo cm9taXVtOjpjcmVhdGVMYXllclRleHR1cmUoKQogewpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXgg OGY0NGFmZWJkMGEyYzdiNDc1ZDA0YmE0ODcyM2YxY2RjNTQ1NTA5MS4uZmZlNDE0MjNkNTNlM2Y1 NDBlNzEwMjMzZmFmMmEwZjgxNTYyY2U1NyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaAorKysgYi9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC02NCw2 ICs2NCw3IEBAIHB1YmxpYzoKICAgICAvLyBVcGRhdGVzIHRoZSBjb250ZW50cyBvZiB0aGUgcm9v dCBsYXllciB0aGF0IGZhbGwgaW5zaWRlIHRoZSB1cGRhdGVSZWN0IGFuZCByZWNvbXBvc2l0ZXMK ICAgICAvLyBhbGwgdGhlIGxheWVycy4KICAgICB2b2lkIGRyYXdMYXllcnMoY29uc3QgSW50UmVj dCYgdXBkYXRlUmVjdCwgY29uc3QgSW50UmVjdCYgdmlzaWJsZVJlY3QsIGNvbnN0IEludFJlY3Qm IGNvbnRlbnRSZWN0LCBjb25zdCBJbnRQb2ludCYgc2Nyb2xsUG9zaXRpb24pOworICAgIHZvaWQg cHJlc2VudCgpOyAvLyBQZXJmb3JtIGJ1ZmZlciBzd2FwIHRvIHByZXNlbnQgcmVuZGVyZWQgYnVm ZmVyLgogCiAgICAgdm9pZCBzZXRSb290TGF5ZXIoUGFzc1JlZlB0cjxMYXllckNocm9taXVtPiBs YXllcikgeyBtX3Jvb3RMYXllciA9IGxheWVyOyB9CiAgICAgTGF5ZXJDaHJvbWl1bSogcm9vdExh eWVyKCkgeyByZXR1cm4gbV9yb290TGF5ZXIuZ2V0KCk7IH0KQEAgLTkwLDYgKzkxLDkgQEAgcHVi bGljOgogICAgIGNvbnN0IENvbnRlbnRMYXllckNocm9taXVtOjpTaGFyZWRWYWx1ZXMqIGNvbnRl bnRMYXllclNoYXJlZFZhbHVlcygpIGNvbnN0IHsgcmV0dXJuIG1fY29udGVudExheWVyU2hhcmVk VmFsdWVzLmdldCgpOyB9CiAgICAgY29uc3QgQ2FudmFzTGF5ZXJDaHJvbWl1bTo6U2hhcmVkVmFs dWVzKiBjYW52YXNMYXllclNoYXJlZFZhbHVlcygpIGNvbnN0IHsgcmV0dXJuIG1fY2FudmFzTGF5 ZXJTaGFyZWRWYWx1ZXMuZ2V0KCk7IH0KIAorICAgIEludFNpemUgcm9vdExheWVyVGV4dHVyZVNp emUoKSBjb25zdCB7IHJldHVybiBJbnRTaXplKG1fcm9vdExheWVyVGV4dHVyZVdpZHRoLCBtX3Jv b3RMYXllclRleHR1cmVIZWlnaHQpOyB9CisgICAgdm9pZCBnZXRGcmFtZWJ1ZmZlclBpeGVscyh2 b2lkICpwaXhlbHMsIGNvbnN0IEludFJlY3QmIHJlY3QpOworCiBwcml2YXRlOgogICAgIHZvaWQg dXBkYXRlTGF5ZXJzUmVjdXJzaXZlKExheWVyQ2hyb21pdW0qIGxheWVyLCBjb25zdCBUcmFuc2Zv cm1hdGlvbk1hdHJpeCYgcGFyZW50TWF0cml4LCBmbG9hdCBvcGFjaXR5KTsKIApkaWZmIC0tZ2l0 IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cK aW5kZXggOWUwMDMwMmVhOTM4MDFlNDZiZmI3N2RjYjYyMzViMWVlZGMwMGQ3NS4uYzM1NzczNjA4 MDY1NTNjMzM3ZDRkZGI0YTk3YTQ2ZGIyZmM3YTIxZCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MjMgQEAKKzIwMTAtMDktMDMgIFcuIEphbWVzIE1hY0xlYW4gIDx3am1hY2xlYW5AY2hyb21pdW0u b3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtj aHJvbWl1bV0gVGh1bWJuYWlscyBub3QgZ2VuZXJhdGVkIGZvciBHUFUgUmVuZGVyZWQgUGFnZXMK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0MTI3CisK KyAgICAgICAgTW9kaWZpZWQgV2ViVmlld0ltcGw6OnBhaW50KCkgdG8gZGV0ZWN0IG5vbi1udWxs IGNhbnZhcyBwb2ludGVycyB3aGVuCisgICAgICAgIGFjY2VsZXJhdGVkIGNvbXBvc2l0aW5nIGlz IGFjdGl2ZSwgYW5kIGluc3RlYWQgZmlsbHMgdGhlIHBpeGVsIGJ1ZmZlcgorICAgICAgICBmcm9t IHRoZSBHUFUgZnJhbWVidWZmZXIuIEluY2x1ZGVzIHJlLXNjYWxpbmcgc3VwcG9ydCB3aGVuIHBy b3ZpZGVkCisgICAgICAgIGNhbnZhcyBkb2VzIG5vdCBtYXRjaCBzaXplIG9mIGN1cnJlbnQgcmVu ZGVyIGxheWVyLiBMaW1pdHMgcGl4ZWwKKyAgICAgICAgcmVhZGJhY2sgdG8gcmVjdCBwYXNzZWQg dG8gcGFpbnQoKSwgY2xpcHBlZCBieSBzaXplIG9mIHJvb3RMYXllclRleHR1cmUuCisKKyAgICAg ICAgKiBzcmMvV2ViVmlld0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6 cGFpbnQpOgorICAgICAgICAoV2ViS2l0OjpjbGVhclNrQml0bWFwKToKKyAgICAgICAgKFdlYktp dDo6V2ViVmlld0ltcGw6OmRvUGl4ZWxSZWFkYmFja1RvQ2FudmFzKToKKyAgICAgICAgKFdlYktp dDo6Y2xlYXJDR0JpdG1hcCk6CisgICAgICAgICogc3JjL1dlYlZpZXdJbXBsLmg6CisKIDIwMTAt MDgtMzEgIEplcmVteSBPcmxvdyAgPGpvcmxvd0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgU3RldmUgQmxvY2suCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YlZpZXdJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4 IDRiMTI5ZDY5NGIxZjExMmYyN2IyMWFlNzI0ZGI2N2E2OGE3NGUwMmEuLmYzMGUwNzk4MGRkNjAw YmE3YWQ3MWJlYzJjZTJkY2VkM2EzY2FmMTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwu Y3BwCkBAIC02NCw3ICs2NCw2IEBACiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAi SW1hZ2UuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JDb250cm9sbGVyLmgiCi0jaW5jbHVkZSAiSW50 UmVjdC5oIgogI2luY2x1ZGUgIktleWJvYXJkQ29kZXMuaCIKICNpbmNsdWRlICJLZXlib2FyZEV2 ZW50LmgiCiAjaW5jbHVkZSAiTUlNRVR5cGVSZWdpc3RyeS5oIgpAQCAtMTE1LDYgKzExNCwxMCBA QAogI2luY2x1ZGUgIldlYlZpZXdDbGllbnQuaCIKICNpbmNsdWRlICJ3dGYvT3duUHRyLmgiCiAK KyNpZiBQTEFURk9STShDRykKKyNpbmNsdWRlIDxDb3JlR3JhcGhpY3MvQ0dDb250ZXh0Lmg+Cisj ZW5kaWYKKwogI2lmIE9TKFdJTkRPV1MpCiAjaW5jbHVkZSAiUmVuZGVyVGhlbWVDaHJvbWl1bVdp bi5oIgogI2Vsc2UKQEAgLTk2OCwxMCArOTcxLDExNSBAQCB2b2lkIFdlYlZpZXdJbXBsOjpwYWlu dChXZWJDYW52YXMqIGNhbnZhcywgY29uc3QgV2ViUmVjdCYgcmVjdCkKIAogICAgICAgICAvLyBB c2sgdGhlIGxheWVyIGNvbXBvc2l0b3IgdG8gcmVkcmF3IGFsbCB0aGUgbGF5ZXJzLgogICAgICAg ICBtX2xheWVyUmVuZGVyZXItPmRyYXdMYXllcnMocmVjdCwgdmlzaWJsZVJlY3QsIGNvbnRlbnRS ZWN0LCBJbnRQb2ludCh2aWV3LT5zY3JvbGxYKCksIHZpZXctPnNjcm9sbFkoKSkpOworCisgICAg ICAgIC8vIElmIGEgY2FudmFzIHdhcyBwYXNzZWQgaW4sIHdlIHVzZSBpdCB0byBncmFiIGEgY29w eSBvZiB0aGUKKyAgICAgICAgLy8gZnJlc2hseS1yZW5kZXJlZCBwaXhlbHMuCisgICAgICAgIGlm IChjYW52YXMpIHsKKyAgICAgICAgICAgIC8vIENsaXAgcmVjdCB0byB0aGUgY29uZmluZXMgb2Yg dGhlIHJvb3RMYXllclRleHR1cmUuCisgICAgICAgICAgICBJbnRSZWN0IHJlc2l6ZVJlY3QocmVj dC54LCByZWN0LnksIHJlY3Qud2lkdGgsIHJlY3QuaGVpZ2h0KTsKKyAgICAgICAgICAgIHJlc2l6 ZVJlY3QuaW50ZXJzZWN0KEludFJlY3QoSW50UG9pbnQoKSwgbV9sYXllclJlbmRlcmVyLT5yb290 TGF5ZXJUZXh0dXJlU2l6ZSgpKSk7CisgICAgICAgICAgICBkb1BpeGVsUmVhZGJhY2tUb0NhbnZh cyhjYW52YXMsIHJlc2l6ZVJlY3QpOworICAgICAgICB9CisKKyAgICAgICAgbV9sYXllclJlbmRl cmVyLT5wcmVzZW50KCk7IC8vIERvIGZpbmFsIGRpc3BsYXkgYnkgc3dhcHBpbmcgYnVmZmVycy4K ICAgICB9CiAjZW5kaWYKIH0KIAorI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKKyNp ZiBQTEFURk9STShTS0lBKQorc3RhdGljIGlubGluZSB2b2lkIGNsZWFyU2tCaXRtYXAoY29uc3Qg U2tCaXRtYXAmIGJpdG1hcCkKK3sKKyAgICBiaXRtYXAuZXJhc2VDb2xvcihTa0NvbG9yU2V0QVJH QigwLCAwLCAwLCAwKSk7Cit9CisKK3ZvaWQgV2ViVmlld0ltcGw6OmRvUGl4ZWxSZWFkYmFja1Rv Q2FudmFzKFdlYkNhbnZhcyogY2FudmFzLCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIEFT U0VSVChyZWN0LnJpZ2h0KCkgPD0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlU2l6 ZSgpLndpZHRoKCkKKyAgICAgICAgICAgJiYgcmVjdC5ib3R0b20oKSA8PSBtX2xheWVyUmVuZGVy ZXItPnJvb3RMYXllclRleHR1cmVTaXplKCkuaGVpZ2h0KCkpOworCisgICAgdm9pZCogcGl4ZWxz ID0gMDsKKyAgICBjb25zdCBTa0JpdG1hcCBiaXRtYXAgPSBjYW52YXMtPmdldERldmljZSgpLT5h Y2Nlc3NCaXRtYXAoZmFsc2UpOworICAgIGlmIChiaXRtYXAuY29uZmlnKCkgPT0gU2tCaXRtYXA6 OmtBUkdCXzg4ODhfQ29uZmlnKSB7CisgICAgICAgIEludFJlY3QgYml0bWFwUmVjdCgwLCAwLCBi aXRtYXAud2lkdGgoKSwgYml0bWFwLmhlaWdodCgpKTsKKworICAgICAgICBpZiAocmVjdCA9PSBi aXRtYXBSZWN0KSB7CisgICAgICAgICAgICBTa0F1dG9Mb2NrUGl4ZWxzIGJpdG1hcExvY2soYml0 bWFwKTsKKyAgICAgICAgICAgIHBpeGVscyA9IGJpdG1hcC5nZXRQaXhlbHMoKTsKKyAgICAgICAg ICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCByZWN0KTsK KyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIC8vIENyZWF0ZSB0ZW1wIGJpdG1hcCBvZiBj b3JyZWN0IHNpemUgdG8gY29weSBwaXhlbHMgaW50by4KKyAgICAgICAgICAgIHNraWE6OlBsYXRm b3JtQ2FudmFzIGNhbnZhc1Jlc2l6ZTsKKyAgICAgICAgICAgIGlmIChjYW52YXNSZXNpemUuaW5p dGlhbGl6ZShyZWN0LndpZHRoKCksIHJlY3QuaGVpZ2h0KCksIHRydWUpKSB7CisgICAgICAgICAg ICAgICAgU2tCaXRtYXAgYml0bWFwUmVzaXplID0gY2FudmFzUmVzaXplLmdldERldmljZSgpLT5h Y2Nlc3NCaXRtYXAoZmFsc2UpOworICAgICAgICAgICAgICAgIHBpeGVscyA9IGJpdG1hcFJlc2l6 ZS5nZXRQaXhlbHMoKTsKKyAgICAgICAgICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdldEZyYW1l YnVmZmVyUGl4ZWxzKHBpeGVscywgcmVjdCk7CisgICAgICAgICAgICAgICAgU2tJUmVjdCBzcmNS ZWN0KEludFJlY3QoSW50UG9pbnQoKSwgcmVjdC5zaXplKCkpKTsKKyAgICAgICAgICAgICAgICBT a1JlY3QgZHN0UmVjdChyZWN0KTsKKyAgICAgICAgICAgICAgICBjYW52YXMtPmRyYXdCaXRtYXBS ZWN0KGJpdG1hcFJlc2l6ZSwgJnNyY1JlY3QsIGRzdFJlY3QsIDApOworICAgICAgICAgICAgfSBl bHNlIHsKKyAgICAgICAgICAgICAgICBjbGVhclNrQml0bWFwKGJpdG1hcCk7CisgICAgICAgICAg ICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAg ICB9IGVsc2UgeworICAgICAgICBjbGVhclNrQml0bWFwKGJpdG1hcCk7CisgICAgICAgIEFTU0VS VF9OT1RfUkVBQ0hFRCgpOworICAgIH0KK30KKworI2VsaWYgUExBVEZPUk0oQ0cpCitzdGF0aWMg aW5saW5lIHZvaWQgY2xlYXJDR0JpdG1hcChjb25zdCBDR0NvbnRleHRSZWYmIGJpdG1hcCkKK3sK KyAgICBDR0NvbnRleHRDbGVhclJlY3QoYml0bWFwLAorICAgICAgICAgICAgICAgICAgICAgICBD R1JlY3RNYWtlKDAsIDAsIENHQml0bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcCksIENHQml0bWFw Q29udGV4dEdldEhlaWdodChiaXRtYXApKSk7Cit9CisKK3ZvaWQgV2ViVmlld0ltcGw6OmRvUGl4 ZWxSZWFkYmFja1RvQ2FudmFzKFdlYkNhbnZhcyogY2FudmFzLCBjb25zdCBJbnRSZWN0JiByZWN0 KQoreworICAgIEFTU0VSVChyZWN0LnJpZ2h0KCkgPD0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5 ZXJUZXh0dXJlU2l6ZSgpLndpZHRoKCkKKyAgICAgICAgICAgJiYgcmVjdC5ib3R0b20oKSA8PSBt X2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVTaXplKCkuaGVpZ2h0KCkpOworCisgICAg dm9pZCogcGl4ZWxzID0gMDsKKyAgICBDR0NvbnRleHRSZWYgYml0bWFwID0gcmVpbnRlcnByZXRf Y2FzdDxDR0NvbnRleHRSZWY+KGNhbnZhcyk7CisgICAgSW50UmVjdCBiaXRtYXBSZWN0KDAsIDAs IENHQml0bWFwQ29udGV4dEdldFdpZHRoKGJpdG1hcCksIENHQml0bWFwQ29udGV4dEdldEhlaWdo dChiaXRtYXApKTsKKyAgICBpZiAoQ0dCaXRtYXBDb250ZXh0R2V0Qnl0ZXNQZXJSb3coYml0bWFw KSA9PSA0dSAqIGJpdG1hcFJlY3Qud2lkdGgoKSkgeworICAgICAgICBpZiAocmVjdCA9PSBiaXRt YXBSZWN0KSB7CisgICAgICAgICAgcGl4ZWxzID0gQ0dCaXRtYXBDb250ZXh0R2V0RGF0YShiaXRt YXApOworICAgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4 ZWxzLCByZWN0KTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIC8vIENyZWF0ZSB0ZW1w IGJpdG1hcCBvZiBzYW1lIHNpemUgYXMgcmVuZGVyZWQgbGF5ZXIgdG8gY29weSBwaXhlbHMgaW50 by4KKyAgICAgICAgICAgIENHQ29sb3JTcGFjZVJlZiBjb2xvclNwYWNlID0gQ0dDb2xvclNwYWNl Q3JlYXRlRGV2aWNlUkdCKCk7CisgICAgICAgICAgICBDR0NvbnRleHRSZWYgYml0bWFwUmVzaXpl ID0gQ0dCaXRtYXBDb250ZXh0Q3JlYXRlKDAsIHJlY3Qud2lkdGgoKSwgcmVjdC5oZWlnaHQoKSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgOCwgNCAqIHJlY3Qud2lkdGgoKSwgY29sb3JTcGFjZSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAga0NHSW1hZ2VBbHBo YVByZW11bHRpcGxpZWRMYXN0KTsKKyAgICAgICAgICAgIGlmIChiaXRtYXBSZXNpemUpIHsKKyAg ICAgICAgICAgICAgcGl4ZWxzID0gQ0dCaXRtYXBDb250ZXh0R2V0RGF0YShiaXRtYXBSZXNpemUp OworICAgICAgICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdldEZyYW1lYnVmZmVyUGl4ZWxzKHBp eGVscywgcmVjdCk7CisKKyAgICAgICAgICAgICAgLy8gQ29weSBiaXRtYXAgYmFjayB0byBpbnB1 dCBiaXRtYXAuIFRoZSBpbWFnZSBpcyBpbnZlcnRlZCBhY2NvcmRpbmcgdG8gQ0csCisgICAgICAg ICAgICAgIC8vIHNvIHNldCB1cCB0aGUgYXBwcm9wcmlhdGUgdHJhbnNmb3JtIHRvIGludmVydCB2 ZXJ0aWNhbCBheGlzIGFuZCBtb3ZlIG9yaWdpbgorICAgICAgICAgICAgICAvLyB0byBib3R0b20g bGVmdC4KKyAgICAgICAgICAgICAgQ0dDb250ZXh0U2F2ZUdTdGF0ZShiaXRtYXApOworICAgICAg ICAgICAgICBDR0NvbnRleHREcmF3SW1hZ2UoYml0bWFwLCByZWN0LAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlSW1hZ2UoYml0bWFwUmVzaXpl KSk7CisgICAgICAgICAgICAgIENHQ29udGV4dFJlc3RvcmVHU3RhdGUoYml0bWFwKTsKKyAgICAg ICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgY2xlYXJDR0JpdG1hcChiaXRtYXApOwor ICAgICAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgfQorICAg ICAgICB9CisgICAgfSBlbHNlIHsKKyAgICAgICAgY2xlYXJDR0JpdG1hcChiaXRtYXApOworICAg ICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9Cit9CisjZWxzZQorI2Vycm9yIE11c3Qg cG9ydCB0byB5b3VyIHBsYXRmb3JtLgorI2VuZGlmCisKKyNlbmRpZgorCiAvLyBGSVhNRTogbV9j dXJyZW50SW5wdXRFdmVudCBzaG91bGQgYmUgcmVtb3ZlZCBvbmNlIENocm9tZUNsaWVudDo6c2hv dygpIGNhbgogLy8gZ2V0IHRoZSBjdXJyZW50LWV2ZW50IGluZm9ybWF0aW9uIGZyb20gV2ViQ29y ZS4KIGNvbnN0IFdlYklucHV0RXZlbnQqIFdlYlZpZXdJbXBsOjptX2N1cnJlbnRJbnB1dEV2ZW50 ID0gMDsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaCBiL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAppbmRleCBjMjk2MTIxMjNmNDUxNGM5NGRk N2Q5NzBjNzMxMTRhNGJlZWVjMzU1Li5kMjAwM2E0ZWE2MWQ5NTkwZWZmYTYyODNmYWNiM2ZiNzg3 Njc2M2UxIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBAIC00NSw2ICs0NSw3IEBACiAj aW5jbHVkZSAiRWRpdG9yQ2xpZW50SW1wbC5oIgogI2luY2x1ZGUgIkdyYXBoaWNzTGF5ZXIuaCIK ICNpbmNsdWRlICJJbnNwZWN0b3JDbGllbnRJbXBsLmgiCisjaW5jbHVkZSA8SW50UmVjdC5oPgog I2luY2x1ZGUgIkxheWVyUmVuZGVyZXJDaHJvbWl1bS5oIgogI2luY2x1ZGUgIk5vdGlmaWNhdGlv blByZXNlbnRlckltcGwuaCIKICNpbmNsdWRlICJTcGVlY2hJbnB1dENsaWVudEltcGwuaCIKQEAg LTM4Niw2ICszODcsNyBAQCBwcml2YXRlOgogI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElO RykKICAgICB2b2lkIHNldElzQWNjZWxlcmF0ZWRDb21wb3NpdGluZ0FjdGl2ZShib29sKTsKICAg ICB2b2lkIHVwZGF0ZVJvb3RMYXllckNvbnRlbnRzKGNvbnN0IFdlYlJlY3QmKTsKKyAgICB2b2lk IGRvUGl4ZWxSZWFkYmFja1RvQ2FudmFzKFdlYkNhbnZhcyosIGNvbnN0IFdlYkNvcmU6OkludFJl Y3QmKTsKICNlbmRpZgogCiAgICAgV2ViVmlld0NsaWVudCogbV9jbGllbnQ7Cg== 66911 2010-09-08 10:34:12 -0700 2010-09-09 11:19:25 -0700 Patch bug-44127-20100908133443.patch text/plain 12206 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZGM0Zjc1ODE2OGE2NTViMzE4ZjY4MWE2Yjg1MDQxMzQ5Njg3ZGExOC4uYWZjN2EyMzMzZDBmYzRm YTgzMjI3ZTcyMThmYmJhYjkxZDNjOGVkNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOS0wOCAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKyAgICAgICAgQWRkcyBw aXhlbC1yZWFkYmFjayBmb3IgR1BVIGNvbXBvc2l0ZWQgcGFnZXMgdG8gYWxsb3cgZm9yIHRodW1i bmFpbGluZywKKyAgICAgICAgcHJpbnRpbmcgYW5kIG90aGVyIHNlcnZpY2VzIHRvIHdvcmsgd2l0 aCBHUFUgcmVuZGVyZWQgcGFnZXMuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVu ZGVyZXJDaHJvbWl1bTo6cHJlc2VudCk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVy Q2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaDoKKyAgICAgICAgKFdlYkNvcmU6 OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6cm9vdExheWVyVGV4dHVyZVNpemUpOgorCiAyMDEwLTA5 LTA3ICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KIAogICAgICAgICBB ZGQgcmVuZGVyaW5nL0NvbHVtbkluZm8uaCB0byB0aGUgc291cmNlcyBsaXN0LgpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21p dW0uY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVy Q2hyb21pdW0uY3BwCmluZGV4IDc4OTI5OGFlZDhjZTk3NjMwMjBjZmUwYWUyMjQ4ZTM3MzNkZjJj OGMuLmY5NDgyMjg4N2ZhNGI2MTgxM2JkNGRmZGI4YjU5ZTI5ZWViMjI5NzggMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVt LmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVy ZXJDaHJvbWl1bS5jcHAKQEAgLTMyOCwxMSArMzI4LDMwIEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNo cm9taXVtOjpkcmF3TGF5ZXJzKGNvbnN0IEludFJlY3QmIHVwZGF0ZVJlY3QsIGNvbnN0IEludFJl Y3QmCiAKICAgICBHTEMoZ2xEaXNhYmxlKEdMX1NDSVNTT1JfVEVTVCkpOwogCisgICAgZ2xGbHVz aCgpOworfQorCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6cHJlc2VudCgpCit7CiAgICAg bV9nbGVzMkNvbnRleHQtPnN3YXBCdWZmZXJzKCk7CiAKICAgICBtX25lZWRzRGlzcGxheSA9IGZh bHNlOwogfQogCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhl bHModm9pZCAqcGl4ZWxzLCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIEFTU0VSVChyZWN0 LnJpZ2h0KCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUoKS53aWR0aCgpCisgICAgICAgICAgICYm IHJlY3QuYm90dG9tKCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUoKS5oZWlnaHQoKSk7CisKKyAg ICBpZiAoIXBpeGVscykKKyAgICAgICAgcmV0dXJuOworCisgICAgbWFrZUNvbnRleHRDdXJyZW50 KCk7CisKKyAgICBHTEMoZ2xSZWFkUGl4ZWxzKHJlY3QueCgpLCByZWN0LnkoKSwgcmVjdC53aWR0 aCgpLCByZWN0LmhlaWdodCgpLAorICAgICAgICAgICAgICAgICAgICAgR0xfUkdCQSwgR0xfVU5T SUdORURfQllURSwgcGl4ZWxzKSk7Cit9CisKIC8vIEZJWE1FOiBUaGlzIG1ldGhvZCBzaG91bGQg ZXZlbnR1YWxseSBiZSByZXBsYWNlZCBieSBhIHByb3BlciB0ZXh0dXJlIG1hbmFnZXIuCiB1bnNp Z25lZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmNyZWF0ZUxheWVyVGV4dHVyZSgpCiB7CmRpZmYg LS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uaAppbmRleCA4ZjQ0YWZlYmQwYTJjN2I0NzVkMDRiYTQ4NzIzZjFjZGM1NDU1 MDkxLi5mZmU0MTQyM2Q1M2UzZjU0MGU3MTAyMzNmYWYyYTBmODE1NjJjZTU3IDEwMDY0NAotLS0g YS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1 bS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmgKQEAgLTY0LDYgKzY0LDcgQEAgcHVibGljOgogICAgIC8vIFVwZGF0ZXMgdGhl IGNvbnRlbnRzIG9mIHRoZSByb290IGxheWVyIHRoYXQgZmFsbCBpbnNpZGUgdGhlIHVwZGF0ZVJl Y3QgYW5kIHJlY29tcG9zaXRlcwogICAgIC8vIGFsbCB0aGUgbGF5ZXJzLgogICAgIHZvaWQgZHJh d0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0JiB2aXNpYmxl UmVjdCwgY29uc3QgSW50UmVjdCYgY29udGVudFJlY3QsIGNvbnN0IEludFBvaW50JiBzY3JvbGxQ b3NpdGlvbik7CisgICAgdm9pZCBwcmVzZW50KCk7IC8vIFBlcmZvcm0gYnVmZmVyIHN3YXAgdG8g cHJlc2VudCByZW5kZXJlZCBidWZmZXIuCiAKICAgICB2b2lkIHNldFJvb3RMYXllcihQYXNzUmVm UHRyPExheWVyQ2hyb21pdW0+IGxheWVyKSB7IG1fcm9vdExheWVyID0gbGF5ZXI7IH0KICAgICBM YXllckNocm9taXVtKiByb290TGF5ZXIoKSB7IHJldHVybiBtX3Jvb3RMYXllci5nZXQoKTsgfQpA QCAtOTAsNiArOTEsOSBAQCBwdWJsaWM6CiAgICAgY29uc3QgQ29udGVudExheWVyQ2hyb21pdW06 OlNoYXJlZFZhbHVlcyogY29udGVudExheWVyU2hhcmVkVmFsdWVzKCkgY29uc3QgeyByZXR1cm4g bV9jb250ZW50TGF5ZXJTaGFyZWRWYWx1ZXMuZ2V0KCk7IH0KICAgICBjb25zdCBDYW52YXNMYXll ckNocm9taXVtOjpTaGFyZWRWYWx1ZXMqIGNhbnZhc0xheWVyU2hhcmVkVmFsdWVzKCkgY29uc3Qg eyByZXR1cm4gbV9jYW52YXNMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsgfQogCisgICAgSW50U2l6 ZSByb290TGF5ZXJUZXh0dXJlU2l6ZSgpIGNvbnN0IHsgcmV0dXJuIEludFNpemUobV9yb290TGF5 ZXJUZXh0dXJlV2lkdGgsIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCk7IH0KKyAgICB2b2lkIGdl dEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgSW50UmVjdCYgcmVjdCk7CisK IHByaXZhdGU6CiAgICAgdm9pZCB1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5ZXJDaHJvbWl1bSog bGF5ZXIsIGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0cml4JiBwYXJlbnRNYXRyaXgsIGZsb2F0IG9w YWNpdHkpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0 L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCAwMjNlMWQ3OTdiMzExYjc4NjdjZWFlMzNlM2I3OTZj OGU3ODdhMDQ1Li5hZjUxZTlkYzA1NGRiODZjZWUzZDY3YTBlOTAyNzljZjU2NzJhNTNlIDEwMDY0 NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wOS0wOCAgVy4gSmFtZXMgTWFjTGVhbiAg PHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5vdCBnZW5lcmF0ZWQgZm9y IEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBNb2RpZmllZCBXZWJWaWV3SW1wbDo6cGFpbnQo KSB0byBkZXRlY3Qgbm9uLW51bGwgY2FudmFzIHBvaW50ZXJzIHdoZW4KKyAgICAgICAgYWNjZWxl cmF0ZWQgY29tcG9zaXRpbmcgaXMgYWN0aXZlLCBhbmQgaW5zdGVhZCBmaWxscyB0aGUgcGl4ZWwg YnVmZmVyCisgICAgICAgIGZyb20gdGhlIEdQVSBmcmFtZWJ1ZmZlci4gSW5jbHVkZXMgcmUtc2Nh bGluZyBzdXBwb3J0IHdoZW4gcHJvdmlkZWQKKyAgICAgICAgY2FudmFzIGRvZXMgbm90IG1hdGNo IHNpemUgb2YgY3VycmVudCByZW5kZXIgbGF5ZXIuIExpbWl0cyBwaXhlbAorICAgICAgICByZWFk YmFjayB0byByZWN0IHBhc3NlZCB0byBwYWludCgpLCBjbGlwcGVkIGJ5IHNpemUgb2Ygcm9vdExh eWVyVGV4dHVyZS4KKworICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYlZpZXdJbXBsOjpwYWludCk6CisgICAgICAgIChXZWJLaXQ6OmNsZWFyU2tCaXRt YXApOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6ZG9QaXhlbFJlYWRiYWNrVG9DYW52 YXMpOgorICAgICAgICAoV2ViS2l0OjpjbGVhckNHQml0bWFwKToKKyAgICAgICAgKiBzcmMvV2Vi Vmlld0ltcGwuaDoKKwogMjAxMC0wOS0wNyAgRGltaXRyaSBHbGF6a292ICA8ZGdsYXprb3ZAY2hy b21pdW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI2Njg4Ni4KZGlm ZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKaW5kZXggZjYzYzkwODI1NjI2Y2IwNmNiYzZmMGE1 YTM1ZjIyN2JiZDViZTc4Mi4uNmM1MTc3NzZjZDhlZTNkM2RkMTU2MTk0ZWMyYjc1MDg1Y2E4NGVl ZCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTY1LDcgKzY1LDYgQEAKICNp bmNsdWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJJbWFnZS5oIgogI2luY2x1ZGUgIkluc3Bl Y3RvckNvbnRyb2xsZXIuaCIKLSNpbmNsdWRlICJJbnRSZWN0LmgiCiAjaW5jbHVkZSAiS2V5Ym9h cmRDb2Rlcy5oIgogI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJNSU1FVHlw ZVJlZ2lzdHJ5LmgiCkBAIC0xMTUsNyArMTE0LDEyIEBACiAjaW5jbHVkZSAiV2ViU3RyaW5nLmgi CiAjaW5jbHVkZSAiV2ViVmVjdG9yLmgiCiAjaW5jbHVkZSAiV2ViVmlld0NsaWVudC5oIgotI2lu Y2x1ZGUgInd0Zi9Pd25QdHIuaCIKKyNpbmNsdWRlIDx3dGYvT3duQXJyYXlQdHIuaD4KKyNpbmNs dWRlIDx3dGYvT3duUHRyLmg+CisKKyNpZiBQTEFURk9STShDRykKKyNpbmNsdWRlIDxDb3JlR3Jh cGhpY3MvQ0dDb250ZXh0Lmg+CisjZW5kaWYKIAogI2lmIE9TKFdJTkRPV1MpCiAjaW5jbHVkZSAi UmVuZGVyVGhlbWVDaHJvbWl1bVdpbi5oIgpAQCAtOTcyLDEwICs5NzYsMTMyIEBAIHZvaWQgV2Vi Vmlld0ltcGw6OnBhaW50KFdlYkNhbnZhcyogY2FudmFzLCBjb25zdCBXZWJSZWN0JiByZWN0KQog ICAgICAgICAvLyBBc2sgdGhlIGxheWVyIGNvbXBvc2l0b3IgdG8gcmVkcmF3IGFsbCB0aGUgbGF5 ZXJzLgogICAgICAgICBBU1NFUlQobV9sYXllclJlbmRlcmVyLT5oYXJkd2FyZUNvbXBvc2l0aW5n KCkpOwogICAgICAgICBtX2xheWVyUmVuZGVyZXItPmRyYXdMYXllcnMocmVjdCwgdmlzaWJsZVJl Y3QsIGNvbnRlbnRSZWN0LCBJbnRQb2ludCh2aWV3LT5zY3JvbGxYKCksIHZpZXctPnNjcm9sbFko KSkpOworCisgICAgICAgIC8vIElmIGEgY2FudmFzIHdhcyBwYXNzZWQgaW4sIHdlIHVzZSBpdCB0 byBncmFiIGEgY29weSBvZiB0aGUKKyAgICAgICAgLy8gZnJlc2hseS1yZW5kZXJlZCBwaXhlbHMu CisgICAgICAgIGlmIChjYW52YXMpIHsKKyAgICAgICAgICAgIC8vIENsaXAgcmVjdCB0byB0aGUg Y29uZmluZXMgb2YgdGhlIHJvb3RMYXllclRleHR1cmUuCisgICAgICAgICAgICBJbnRSZWN0IHJl c2l6ZVJlY3QocmVjdC54LCByZWN0LnksIHJlY3Qud2lkdGgsIHJlY3QuaGVpZ2h0KTsKKyAgICAg ICAgICAgIHJlc2l6ZVJlY3QuaW50ZXJzZWN0KEludFJlY3QoSW50UG9pbnQoKSwgbV9sYXllclJl bmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlU2l6ZSgpKSk7CisgICAgICAgICAgICBkb1BpeGVsUmVh ZGJhY2tUb0NhbnZhcyhjYW52YXMsIHJlc2l6ZVJlY3QpOworICAgICAgICB9CisKKyAgICAgICAg bV9sYXllclJlbmRlcmVyLT5wcmVzZW50KCk7IC8vIERvIGZpbmFsIGRpc3BsYXkgYnkgc3dhcHBp bmcgYnVmZmVycy4KICAgICB9CiAjZW5kaWYKIH0KIAorI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01Q T1NJVElORykKKyNpZiBQTEFURk9STShTS0lBKQorc3RhdGljIGlubGluZSB2b2lkIGNsZWFyU2tC aXRtYXAoY29uc3QgU2tCaXRtYXAmIGJpdG1hcCkKK3sKKyAgICBiaXRtYXAuZXJhc2VDb2xvcihT a0NvbG9yU2V0QVJHQigwLCAwLCAwLCAwKSk7Cit9CisKK3ZvaWQgV2ViVmlld0ltcGw6OmRvUGl4 ZWxSZWFkYmFja1RvQ2FudmFzKFdlYkNhbnZhcyogY2FudmFzLCBjb25zdCBJbnRSZWN0JiByZWN0 KQoreworICAgIEFTU0VSVChyZWN0LnJpZ2h0KCkgPD0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5 ZXJUZXh0dXJlU2l6ZSgpLndpZHRoKCkKKyAgICAgICAgICAgJiYgcmVjdC5ib3R0b20oKSA8PSBt X2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVTaXplKCkuaGVpZ2h0KCkpOworCisgICAg dm9pZCogcGl4ZWxzID0gMDsKKyAgICBjb25zdCBTa0JpdG1hcCBiaXRtYXAgPSBjYW52YXMtPmdl dERldmljZSgpLT5hY2Nlc3NCaXRtYXAoZmFsc2UpOworICAgIGlmIChiaXRtYXAuY29uZmlnKCkg PT0gU2tCaXRtYXA6OmtBUkdCXzg4ODhfQ29uZmlnKSB7CisgICAgICAgIEludFJlY3QgYml0bWFw UmVjdCgwLCAwLCBiaXRtYXAud2lkdGgoKSwgYml0bWFwLmhlaWdodCgpKTsKKworI2RlZmluZSBB Vk9JRF9TS0lBX1JFQURCQUNLX0NPUFkKKyNpZmRlZiBBVk9JRF9TS0lBX1JFQURCQUNLX0NPUFkK KyAgICAgICAgaWYgKHJlY3QgPT0gYml0bWFwUmVjdCkgeworICAgICAgICAgICAgU2tBdXRvTG9j a1BpeGVscyBiaXRtYXBMb2NrKGJpdG1hcCk7CisgICAgICAgICAgICBwaXhlbHMgPSBiaXRtYXAu Z2V0UGl4ZWxzKCk7CisgICAgICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdldEZyYW1lYnVmZmVy UGl4ZWxzKHBpeGVscywgcmVjdCk7CisKKyAgICAgICAgICAgIC8vIEZsaXAgcGl4ZWxzIHZlcnRp Y2FsbHkuIE9ubHkgbmVlZGVkIHNpbmNlIHdlIGFyZSBtYW5pcHVsYXRpbmcKKyAgICAgICAgICAg IC8vIHRoZSBwaXhlbHMgZGlyZWN0bHkgd2l0aG91dCBleHRyYSBidWZmZXIgKHNlZSBzY2FsZSgp L3RyYW5zbGF0ZSgpIGJlbG93KS4KKyAgICAgICAgICAgIGNvbnN0IGludCByb3dCeXRlcyA9IDQg KiByZWN0LndpZHRoKCk7CisgICAgICAgICAgICBPd25BcnJheVB0cjx1bnNpZ25lZCBjaGFyPiBs aW5lVGVtcChuZXcgdW5zaWduZWQgY2hhcltyb3dCeXRlc10pOworICAgICAgICAgICAgZm9yIChp bnQgcm93MSA9IDAsIHJvdzIgPSByZWN0LmhlaWdodCgpIC0gMTsgcm93MSA8IHJlY3QuaGVpZ2h0 KCkgLyAyOyArK3JvdzEsIC0tcm93MikgeworICAgICAgICAgICAgICAgIHVuc2lnbmVkIGNoYXIq IHB0cjEgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBjaGFyKj4ocGl4ZWxzKSArIHJvdzEgKiByb3dC eXRlczsKKyAgICAgICAgICAgICAgICB1bnNpZ25lZCBjaGFyKiBwdHIyID0gc3RhdGljX2Nhc3Q8 dW5zaWduZWQgY2hhcio+KHBpeGVscykgKyByb3cyICogcm93Qnl0ZXM7CisKKyAgICAgICAgICAg ICAgICBtZW1jcHkobGluZVRlbXAuZ2V0KCksIHB0cjEsIHJvd0J5dGVzKTsKKyAgICAgICAgICAg ICAgICBtZW1jcHkocHRyMSwgcHRyMiwgcm93Qnl0ZXMpOworICAgICAgICAgICAgICAgIG1lbWNw eShwdHIyLCBsaW5lVGVtcC5nZXQoKSwgcm93Qnl0ZXMpOworICAgICAgICAgICAgfQorICAgICAg ICB9IGVsc2UgeworI2VuZGlmCisgICAgICAgICAgICAvLyBDcmVhdGUgdGVtcCBiaXRtYXAgb2Yg Y29ycmVjdCBzaXplIHRvIGNvcHkgcGl4ZWxzIGludG8uCisgICAgICAgICAgICBza2lhOjpQbGF0 Zm9ybUNhbnZhcyBjYW52YXNSZXNpemU7CisgICAgICAgICAgICBpZiAoY2FudmFzUmVzaXplLmlu aXRpYWxpemUocmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpLCB0cnVlKSkgeworICAgICAgICAg ICAgICAgIFNrQml0bWFwIGJpdG1hcFJlc2l6ZSA9IGNhbnZhc1Jlc2l6ZS5nZXREZXZpY2UoKS0+ YWNjZXNzQml0bWFwKGZhbHNlKTsKKyAgICAgICAgICAgICAgICBwaXhlbHMgPSBiaXRtYXBSZXNp emUuZ2V0UGl4ZWxzKCk7CisgICAgICAgICAgICAgICAgbV9sYXllclJlbmRlcmVyLT5nZXRGcmFt ZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHJlY3QpOworICAgICAgICAgICAgICAgIFNrSVJlY3Qgc3Jj UmVjdChJbnRSZWN0KEludFBvaW50KCksIHJlY3Quc2l6ZSgpKSk7CisgICAgICAgICAgICAgICAg U2tSZWN0IGRzdFJlY3QocmVjdCk7CisgICAgICAgICAgICAgICAgY2FudmFzLT5zYXZlKCk7Cisg ICAgICAgICAgICAgICAgY2FudmFzLT50cmFuc2xhdGUoMC4wZiwgYml0bWFwLmhlaWdodCgpKTsK KyAgICAgICAgICAgICAgICBjYW52YXMtPnNjYWxlKDEuMGYsIC0xLjBmKTsKKyAgICAgICAgICAg ICAgICBjYW52YXMtPmRyYXdCaXRtYXBSZWN0KGJpdG1hcFJlc2l6ZSwgJnNyY1JlY3QsIGRzdFJl Y3QsIDApOworICAgICAgICAgICAgICAgIGNhbnZhcy0+cmVzdG9yZSgpOworICAgICAgICAgICAg fSBlbHNlIHsKKyAgICAgICAgICAgICAgICBjbGVhclNrQml0bWFwKGJpdG1hcCk7CisgICAgICAg ICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgICAgICB9CisjaWZkZWYgQVZP SURfU0tJQV9SRUFEQkFDS19DT1BZCisgICAgICAgIH0KKyNlbmRpZgorICAgIH0gZWxzZSB7Cisg ICAgICAgIGNsZWFyU2tCaXRtYXAoYml0bWFwKTsKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVE KCk7CisgICAgfQorfQorCisjZWxpZiBQTEFURk9STShDRykKK3N0YXRpYyBpbmxpbmUgdm9pZCBj bGVhckNHQml0bWFwKGNvbnN0IENHQ29udGV4dFJlZiYgYml0bWFwKQoreworICAgIENHQ29udGV4 dENsZWFyUmVjdChiaXRtYXAsCisgICAgICAgICAgICAgICAgICAgICAgIENHUmVjdE1ha2UoMCwg MCwgQ0dCaXRtYXBDb250ZXh0R2V0V2lkdGgoYml0bWFwKSwgQ0dCaXRtYXBDb250ZXh0R2V0SGVp Z2h0KGJpdG1hcCkpKTsKK30KKwordm9pZCBXZWJWaWV3SW1wbDo6ZG9QaXhlbFJlYWRiYWNrVG9D YW52YXMoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgQVNT RVJUKHJlY3QucmlnaHQoKSA8PSBtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVTaXpl KCkud2lkdGgoKQorICAgICAgICAgICAmJiByZWN0LmJvdHRvbSgpIDw9IG1fbGF5ZXJSZW5kZXJl ci0+cm9vdExheWVyVGV4dHVyZVNpemUoKS5oZWlnaHQoKSk7CisKKyAgICB2b2lkKiBwaXhlbHMg PSAwOworICAgIENHQ29udGV4dFJlZiBiaXRtYXAgPSByZWludGVycHJldF9jYXN0PENHQ29udGV4 dFJlZj4oY2FudmFzKTsKKyAgICBJbnRSZWN0IGJpdG1hcFJlY3QoMCwgMCwgQ0dCaXRtYXBDb250 ZXh0R2V0V2lkdGgoYml0bWFwKSwgQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KGJpdG1hcCkpOwor ICAgIGlmIChDR0JpdG1hcENvbnRleHRHZXRCeXRlc1BlclJvdyhiaXRtYXApID09IDR1ICogYml0 bWFwUmVjdC53aWR0aCgpKSB7CisgICAgICAgIGlmIChyZWN0ID09IGJpdG1hcFJlY3QpIHsKKyAg ICAgICAgICBwaXhlbHMgPSBDR0JpdG1hcENvbnRleHRHZXREYXRhKGJpdG1hcCk7CisgICAgICAg ICAgbV9sYXllclJlbmRlcmVyLT5nZXRGcmFtZWJ1ZmZlclBpeGVscyhwaXhlbHMsIHJlY3QpOwor ICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgLy8gQ3JlYXRlIHRlbXAgYml0bWFwIG9mIHNh bWUgc2l6ZSBhcyByZW5kZXJlZCBsYXllciB0byBjb3B5IHBpeGVscyBpbnRvLgorICAgICAgICAg ICAgQ0dDb2xvclNwYWNlUmVmIGNvbG9yU3BhY2UgPSBDR0NvbG9yU3BhY2VDcmVhdGVEZXZpY2VS R0IoKTsKKyAgICAgICAgICAgIENHQ29udGV4dFJlZiBiaXRtYXBSZXNpemUgPSBDR0JpdG1hcENv bnRleHRDcmVhdGUoMCwgcmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA4LCA0ICog cmVjdC53aWR0aCgpLCBjb2xvclNwYWNlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBrQ0dJbWFnZUFscGhhUHJlbXVsdGlwbGll ZExhc3QpOworICAgICAgICAgICAgaWYgKGJpdG1hcFJlc2l6ZSkgeworICAgICAgICAgICAgICBw aXhlbHMgPSBDR0JpdG1hcENvbnRleHRHZXREYXRhKGJpdG1hcFJlc2l6ZSk7CisgICAgICAgICAg ICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMocGl4ZWxzLCByZWN0KTsK KworICAgICAgICAgICAgICBDR0NvbnRleHREcmF3SW1hZ2UoYml0bWFwLCByZWN0LAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgQ0dCaXRtYXBDb250ZXh0Q3JlYXRlSW1hZ2UoYml0 bWFwUmVzaXplKSk7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIGNsZWFy Q0dCaXRtYXAoYml0bWFwKTsKKyAgICAgICAgICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0gZWxzZSB7CisgICAgICAgIGNsZWFyQ0dC aXRtYXAoYml0bWFwKTsKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorfQor I2Vsc2UKKyNlcnJvciBNdXN0IHBvcnQgdG8geW91ciBwbGF0Zm9ybS4KKyNlbmRpZgorCisjZW5k aWYKKwogLy8gRklYTUU6IG1fY3VycmVudElucHV0RXZlbnQgc2hvdWxkIGJlIHJlbW92ZWQgb25j ZSBDaHJvbWVDbGllbnQ6OnNob3coKSBjYW4KIC8vIGdldCB0aGUgY3VycmVudC1ldmVudCBpbmZv cm1hdGlvbiBmcm9tIFdlYkNvcmUuCiBjb25zdCBXZWJJbnB1dEV2ZW50KiBXZWJWaWV3SW1wbDo6 bV9jdXJyZW50SW5wdXRFdmVudCA9IDA7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYlZpZXdJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKaW5kZXgg YTQyMDk5YzlkNWY0ODQzYzJmM2U0N2Q3NTM3N2Q0ZDVhMGY3ZTlmMS4uYjFmMTYzMmJmZTdjODJh MjMwNTlmODg3ZDIyMDhkZjczNjcxYjc2ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJWaWV3SW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaApA QCAtNDUsNiArNDUsNyBAQAogI2luY2x1ZGUgIkVkaXRvckNsaWVudEltcGwuaCIKICNpbmNsdWRl ICJHcmFwaGljc0xheWVyLmgiCiAjaW5jbHVkZSAiSW5zcGVjdG9yQ2xpZW50SW1wbC5oIgorI2lu Y2x1ZGUgPEludFJlY3QuaD4KICNpbmNsdWRlICJMYXllclJlbmRlcmVyQ2hyb21pdW0uaCIKICNp bmNsdWRlICJOb3RpZmljYXRpb25QcmVzZW50ZXJJbXBsLmgiCiAjaW5jbHVkZSAiU3BlZWNoSW5w dXRDbGllbnRJbXBsLmgiCkBAIC0zODcsNiArMzg4LDcgQEAgcHJpdmF0ZToKICNpZiBVU0UoQUND RUxFUkFURURfQ09NUE9TSVRJTkcpCiAgICAgdm9pZCBzZXRJc0FjY2VsZXJhdGVkQ29tcG9zaXRp bmdBY3RpdmUoYm9vbCk7CiAgICAgdm9pZCB1cGRhdGVSb290TGF5ZXJDb250ZW50cyhjb25zdCBX ZWJSZWN0Jik7CisgICAgdm9pZCBkb1BpeGVsUmVhZGJhY2tUb0NhbnZhcyhXZWJDYW52YXMqLCBj b25zdCBXZWJDb3JlOjpJbnRSZWN0Jik7CiAjZW5kaWYKIAogICAgIFdlYlZpZXdDbGllbnQqIG1f Y2xpZW50Owo= 67071 2010-09-09 11:19:32 -0700 2010-09-09 13:28:01 -0700 Patch bug-44127-20100909142009.patch text/plain 9118 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZGM0Zjc1ODE2OGE2NTViMzE4ZjY4MWE2Yjg1MDQxMzQ5Njg3ZGExOC4uYzMwZDBjOTk4N2U2ZTBm MTdmNGYwZmU0ODI0Zjc3OGVjMjM1YTEyZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOS0wOSAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKyAgICAgICAgQWRkcyBw aXhlbC1yZWFkYmFjayBmb3IgR1BVIGNvbXBvc2l0ZWQgcGFnZXMgdG8gYWxsb3cgZm9yIHRodW1i bmFpbGluZywKKyAgICAgICAgcHJpbnRpbmcgYW5kIG90aGVyIHNlcnZpY2VzIHRvIHdvcmsgd2l0 aCBHUFUgcmVuZGVyZWQgcGFnZXMuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVu ZGVyZXJDaHJvbWl1bTo6cHJlc2VudCk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVy Q2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaDoKKyAgICAgICAgKFdlYkNvcmU6 OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6cm9vdExheWVyVGV4dHVyZVNpemUpOgorCiAyMDEwLTA5 LTA3ICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KIAogICAgICAgICBB ZGQgcmVuZGVyaW5nL0NvbHVtbkluZm8uaCB0byB0aGUgc291cmNlcyBsaXN0LgpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21p dW0uY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVy Q2hyb21pdW0uY3BwCmluZGV4IDc4OTI5OGFlZDhjZTk3NjMwMjBjZmUwYWUyMjQ4ZTM3MzNkZjJj OGMuLmY5NDgyMjg4N2ZhNGI2MTgxM2JkNGRmZGI4YjU5ZTI5ZWViMjI5NzggMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVt LmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVy ZXJDaHJvbWl1bS5jcHAKQEAgLTMyOCwxMSArMzI4LDMwIEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNo cm9taXVtOjpkcmF3TGF5ZXJzKGNvbnN0IEludFJlY3QmIHVwZGF0ZVJlY3QsIGNvbnN0IEludFJl Y3QmCiAKICAgICBHTEMoZ2xEaXNhYmxlKEdMX1NDSVNTT1JfVEVTVCkpOwogCisgICAgZ2xGbHVz aCgpOworfQorCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6cHJlc2VudCgpCit7CiAgICAg bV9nbGVzMkNvbnRleHQtPnN3YXBCdWZmZXJzKCk7CiAKICAgICBtX25lZWRzRGlzcGxheSA9IGZh bHNlOwogfQogCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhl bHModm9pZCAqcGl4ZWxzLCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIEFTU0VSVChyZWN0 LnJpZ2h0KCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUoKS53aWR0aCgpCisgICAgICAgICAgICYm IHJlY3QuYm90dG9tKCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUoKS5oZWlnaHQoKSk7CisKKyAg ICBpZiAoIXBpeGVscykKKyAgICAgICAgcmV0dXJuOworCisgICAgbWFrZUNvbnRleHRDdXJyZW50 KCk7CisKKyAgICBHTEMoZ2xSZWFkUGl4ZWxzKHJlY3QueCgpLCByZWN0LnkoKSwgcmVjdC53aWR0 aCgpLCByZWN0LmhlaWdodCgpLAorICAgICAgICAgICAgICAgICAgICAgR0xfUkdCQSwgR0xfVU5T SUdORURfQllURSwgcGl4ZWxzKSk7Cit9CisKIC8vIEZJWE1FOiBUaGlzIG1ldGhvZCBzaG91bGQg ZXZlbnR1YWxseSBiZSByZXBsYWNlZCBieSBhIHByb3BlciB0ZXh0dXJlIG1hbmFnZXIuCiB1bnNp Z25lZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmNyZWF0ZUxheWVyVGV4dHVyZSgpCiB7CmRpZmYg LS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uaAppbmRleCA4ZjQ0YWZlYmQwYTJjN2I0NzVkMDRiYTQ4NzIzZjFjZGM1NDU1 MDkxLi5mZmU0MTQyM2Q1M2UzZjU0MGU3MTAyMzNmYWYyYTBmODE1NjJjZTU3IDEwMDY0NAotLS0g YS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1 bS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmgKQEAgLTY0LDYgKzY0LDcgQEAgcHVibGljOgogICAgIC8vIFVwZGF0ZXMgdGhl IGNvbnRlbnRzIG9mIHRoZSByb290IGxheWVyIHRoYXQgZmFsbCBpbnNpZGUgdGhlIHVwZGF0ZVJl Y3QgYW5kIHJlY29tcG9zaXRlcwogICAgIC8vIGFsbCB0aGUgbGF5ZXJzLgogICAgIHZvaWQgZHJh d0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0JiB2aXNpYmxl UmVjdCwgY29uc3QgSW50UmVjdCYgY29udGVudFJlY3QsIGNvbnN0IEludFBvaW50JiBzY3JvbGxQ b3NpdGlvbik7CisgICAgdm9pZCBwcmVzZW50KCk7IC8vIFBlcmZvcm0gYnVmZmVyIHN3YXAgdG8g cHJlc2VudCByZW5kZXJlZCBidWZmZXIuCiAKICAgICB2b2lkIHNldFJvb3RMYXllcihQYXNzUmVm UHRyPExheWVyQ2hyb21pdW0+IGxheWVyKSB7IG1fcm9vdExheWVyID0gbGF5ZXI7IH0KICAgICBM YXllckNocm9taXVtKiByb290TGF5ZXIoKSB7IHJldHVybiBtX3Jvb3RMYXllci5nZXQoKTsgfQpA QCAtOTAsNiArOTEsOSBAQCBwdWJsaWM6CiAgICAgY29uc3QgQ29udGVudExheWVyQ2hyb21pdW06 OlNoYXJlZFZhbHVlcyogY29udGVudExheWVyU2hhcmVkVmFsdWVzKCkgY29uc3QgeyByZXR1cm4g bV9jb250ZW50TGF5ZXJTaGFyZWRWYWx1ZXMuZ2V0KCk7IH0KICAgICBjb25zdCBDYW52YXNMYXll ckNocm9taXVtOjpTaGFyZWRWYWx1ZXMqIGNhbnZhc0xheWVyU2hhcmVkVmFsdWVzKCkgY29uc3Qg eyByZXR1cm4gbV9jYW52YXNMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsgfQogCisgICAgSW50U2l6 ZSByb290TGF5ZXJUZXh0dXJlU2l6ZSgpIGNvbnN0IHsgcmV0dXJuIEludFNpemUobV9yb290TGF5 ZXJUZXh0dXJlV2lkdGgsIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCk7IH0KKyAgICB2b2lkIGdl dEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgSW50UmVjdCYgcmVjdCk7CisK IHByaXZhdGU6CiAgICAgdm9pZCB1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5ZXJDaHJvbWl1bSog bGF5ZXIsIGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0cml4JiBwYXJlbnRNYXRyaXgsIGZsb2F0IG9w YWNpdHkpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0 L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCAwMjNlMWQ3OTdiMzExYjc4NjdjZWFlMzNlM2I3OTZj OGU3ODdhMDQ1Li5jY2JhZTNkYjYwMmEyNWY0M2JlMjVhZTcyMWExOTA0MThjMDdiYzVhIDEwMDY0 NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOS0wOSAgVy4gSmFtZXMgTWFjTGVhbiAg PHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5vdCBnZW5lcmF0ZWQgZm9y IEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBNb2RpZmllZCBXZWJWaWV3SW1wbDo6cGFpbnQo KSB0byBkZXRlY3Qgbm9uLW51bGwgY2FudmFzIHBvaW50ZXJzIHdoZW4KKyAgICAgICAgYWNjZWxl cmF0ZWQgY29tcG9zaXRpbmcgaXMgYWN0aXZlLCBhbmQgaW5zdGVhZCBmaWxscyB0aGUgcGl4ZWwg YnVmZmVyCisgICAgICAgIGZyb20gdGhlIEdQVSBmcmFtZWJ1ZmZlci4gSW5jbHVkZXMgcmUtc2Nh bGluZyBzdXBwb3J0IHdoZW4gcHJvdmlkZWQKKyAgICAgICAgY2FudmFzIGRvZXMgbm90IG1hdGNo IHNpemUgb2YgY3VycmVudCByZW5kZXIgbGF5ZXIuIExpbWl0cyBwaXhlbAorICAgICAgICByZWFk YmFjayB0byByZWN0IHBhc3NlZCB0byBwYWludCgpLCBjbGlwcGVkIGJ5IHNpemUgb2Ygcm9vdExh eWVyVGV4dHVyZS4KKworICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYlZpZXdJbXBsOjpkb1BpeGVsUmVhZGJhY2tUb0NhbnZhcyk6CisgICAgICAgIChX ZWJLaXQ6OldlYlZpZXdJbXBsOjpwYWludCk6CisgICAgICAgICogc3JjL1dlYlZpZXdJbXBsLmg6 CisKIDIwMTAtMDktMDcgIERpbWl0cmkgR2xhemtvdiAgPGRnbGF6a292QGNocm9taXVtLm9yZz4K IAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByNjY4ODYuCmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViVmlld0ltcGwuY3BwCmluZGV4IGY2M2M5MDgyNTYyNmNiMDZjYmM2ZjBhNWEzNWYyMjdiYmQ1 YmU3ODIuLmY1ZmE2MjJiZGQ4YjJhMjI2MGM3YWE0YmEzOTdjMzYyOWJmOGY5YjMgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCkBAIC0zNCw2ICszNCw3IEBACiAjaW5jbHVkZSAiQXV0 b0ZpbGxQb3B1cE1lbnVDbGllbnQuaCIKICNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5j bHVkZSAiQ2hyb21lLmgiCisjaW5jbHVkZSAiQ29sb3JTcGFjZS5oIgogI2luY2x1ZGUgIkNvbXBv c2l0aW9uVW5kZXJsaW5lVmVjdG9yQnVpbGRlci5oIgogI2luY2x1ZGUgIkNvbnRleHRNZW51Lmgi CiAjaW5jbHVkZSAiQ29udGV4dE1lbnVDb250cm9sbGVyLmgiCkBAIC02NCw4ICs2NSw5IEBACiAj aW5jbHVkZSAiSGl0VGVzdFJlc3VsdC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1 ZGUgIkltYWdlLmgiCisjaW5jbHVkZSAiSW1hZ2VCdWZmZXIuaCIKKyNpbmNsdWRlICJJbWFnZURh dGEuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JDb250cm9sbGVyLmgiCi0jaW5jbHVkZSAiSW50UmVj dC5oIgogI2luY2x1ZGUgIktleWJvYXJkQ29kZXMuaCIKICNpbmNsdWRlICJLZXlib2FyZEV2ZW50 LmgiCiAjaW5jbHVkZSAiTUlNRVR5cGVSZWdpc3RyeS5oIgpAQCAtMTE1LDcgKzExNywxMSBAQAog I2luY2x1ZGUgIldlYlN0cmluZy5oIgogI2luY2x1ZGUgIldlYlZlY3Rvci5oIgogI2luY2x1ZGUg IldlYlZpZXdDbGllbnQuaCIKLSNpbmNsdWRlICJ3dGYvT3duUHRyLmgiCisjaW5jbHVkZSA8d3Rm L1JlZlB0ci5oPgorCisjaWYgUExBVEZPUk0oQ0cpCisjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NH Q29udGV4dC5oPgorI2VuZGlmCiAKICNpZiBPUyhXSU5ET1dTKQogI2luY2x1ZGUgIlJlbmRlclRo ZW1lQ2hyb21pdW1XaW4uaCIKQEAgLTk0NCw2ICs5NTAsMzkgQEAgdm9pZCBXZWJWaWV3SW1wbDo6 bGF5b3V0KCkKICAgICB9CiB9CiAKKyNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCit2 b2lkIFdlYlZpZXdJbXBsOjpkb1BpeGVsUmVhZGJhY2tUb0NhbnZhcyhXZWJDYW52YXMqIGNhbnZh cywgY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBBU1NFUlQocmVjdC5yaWdodCgpIDw9IG1f bGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVNpemUoKS53aWR0aCgpCisgICAgICAgICAg ICYmIHJlY3QuYm90dG9tKCkgPD0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlU2l6 ZSgpLmhlaWdodCgpKTsKKworI2lmIFBMQVRGT1JNKFNLSUEpCisgICAgUGxhdGZvcm1Db250ZXh0 U2tpYSBjb250ZXh0KGNhbnZhcyk7CisKKyAgICAvLyBQbGF0Zm9ybUdyYXBoaWNzQ29udGV4dCBp cyBhY3R1YWxseSBhIHBvaW50ZXIgdG8gUGxhdGZvcm1Db250ZXh0U2tpYQorICAgIEdyYXBoaWNz Q29udGV4dCBnYyhyZWludGVycHJldF9jYXN0PFBsYXRmb3JtR3JhcGhpY3NDb250ZXh0Kj4oJmNv bnRleHQpKTsKKyAgICBpbnQgYml0bWFwSGVpZ2h0ID0gY2FudmFzLT5nZXREZXZpY2UoKS0+YWNj ZXNzQml0bWFwKGZhbHNlKS5oZWlnaHQoKTsKKyNlbGlmIFBMQVRGT1JNKENHKQorICAgIEdyYXBo aWNzQ29udGV4dCBnYyhjYW52YXMpOworICAgIGludCBiaXRtYXBIZWlnaHQgPSBDR0JpdG1hcENv bnRleHRHZXRIZWlnaHQocmVpbnRlcnByZXRfY2FzdDxDR0NvbnRleHRSZWY+KGNhbnZhcykpOwor I2Vsc2UKKyNlcnJvciBNdXN0IHBvcnQgdG8geW91ciBwbGF0Zm9ybS4KKyNlbmRpZgorCisgICAg T3duUHRyPEltYWdlQnVmZmVyPiBpbWdCdWZmZXIoSW1hZ2VCdWZmZXI6OmNyZWF0ZShyZWN0LnNp emUoKSkpOworICAgIFJlZlB0cjxJbWFnZURhdGE+IGltZ0RhdGEoSW1hZ2VEYXRhOjpjcmVhdGUo cmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpKSk7CisgICAgaWYgKGltZ0J1ZmZlci5nZXQoKSAm JiBpbWdEYXRhLmdldCgpKSB7CisgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZm ZXJQaXhlbHMoaW1nRGF0YS0+ZGF0YSgpLT5kYXRhKCktPmRhdGEoKSwgcmVjdCk7CisgICAgICAg IGltZ0J1ZmZlci0+cHV0UHJlbXVsdGlwbGllZEltYWdlRGF0YShpbWdEYXRhLmdldCgpLCBJbnRS ZWN0KEludFBvaW50KCksIHJlY3Quc2l6ZSgpKSwgSW50UG9pbnQoKSk7CisgICAgICAgIGdjLnNh dmUoKTsKKyAgICAgICAgZ2MudHJhbnNsYXRlKEZsb2F0U2l6ZSgwLjBmLCBiaXRtYXBIZWlnaHQp KTsKKyAgICAgICAgZ2Muc2NhbGUoRmxvYXRTaXplKDEuMGYsIC0xLjBmKSk7CisgICAgICAgIGdj LmRyYXdJbWFnZUJ1ZmZlcihpbWdCdWZmZXIuZ2V0KCksIERldmljZUNvbG9yU3BhY2UsIHJlY3Qu bG9jYXRpb24oKSk7CisgICAgICAgIGdjLnJlc3RvcmUoKTsKKyAgICB9Cit9CisjZW5kaWYKKwog dm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdlYlJlY3Qm IHJlY3QpCiB7CiAKQEAgLTk3Miw2ICsxMDExLDE3IEBAIHZvaWQgV2ViVmlld0ltcGw6OnBhaW50 KFdlYkNhbnZhcyogY2FudmFzLCBjb25zdCBXZWJSZWN0JiByZWN0KQogICAgICAgICAvLyBBc2sg dGhlIGxheWVyIGNvbXBvc2l0b3IgdG8gcmVkcmF3IGFsbCB0aGUgbGF5ZXJzLgogICAgICAgICBB U1NFUlQobV9sYXllclJlbmRlcmVyLT5oYXJkd2FyZUNvbXBvc2l0aW5nKCkpOwogICAgICAgICBt X2xheWVyUmVuZGVyZXItPmRyYXdMYXllcnMocmVjdCwgdmlzaWJsZVJlY3QsIGNvbnRlbnRSZWN0 LCBJbnRQb2ludCh2aWV3LT5zY3JvbGxYKCksIHZpZXctPnNjcm9sbFkoKSkpOworCisgICAgICAg IC8vIElmIGEgY2FudmFzIHdhcyBwYXNzZWQgaW4sIHdlIHVzZSBpdCB0byBncmFiIGEgY29weSBv ZiB0aGUKKyAgICAgICAgLy8gZnJlc2hseS1yZW5kZXJlZCBwaXhlbHMuCisgICAgICAgIGlmIChj YW52YXMpIHsKKyAgICAgICAgICAgIC8vIENsaXAgcmVjdCB0byB0aGUgY29uZmluZXMgb2YgdGhl IHJvb3RMYXllclRleHR1cmUuCisgICAgICAgICAgICBJbnRSZWN0IHJlc2l6ZVJlY3QocmVjdC54 LCByZWN0LnksIHJlY3Qud2lkdGgsIHJlY3QuaGVpZ2h0KTsKKyAgICAgICAgICAgIHJlc2l6ZVJl Y3QuaW50ZXJzZWN0KEludFJlY3QoSW50UG9pbnQoKSwgbV9sYXllclJlbmRlcmVyLT5yb290TGF5 ZXJUZXh0dXJlU2l6ZSgpKSk7CisgICAgICAgICAgICBkb1BpeGVsUmVhZGJhY2tUb0NhbnZhcyhj YW52YXMsIHJlc2l6ZVJlY3QpOworICAgICAgICB9CisKKyAgICAgICAgbV9sYXllclJlbmRlcmVy LT5wcmVzZW50KCk7IC8vIERvIGZpbmFsIGRpc3BsYXkgYnkgc3dhcHBpbmcgYnVmZmVycy4KICAg ICB9CiAjZW5kaWYKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0lt cGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAppbmRleCBhNDIwOTljOWQ1 ZjQ4NDNjMmYzZTQ3ZDc1Mzc3ZDRkNWEwZjdlOWYxLi45OGQyNjdiNTJlMTBlNjRjYzk2OGEzNDZl MGY4MDQyMjhiZTljNWZiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJ bXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBAIC00NSw2ICs0 NSw3IEBACiAjaW5jbHVkZSAiRWRpdG9yQ2xpZW50SW1wbC5oIgogI2luY2x1ZGUgIkdyYXBoaWNz TGF5ZXIuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JDbGllbnRJbXBsLmgiCisjaW5jbHVkZSAiSW50 UmVjdC5oIgogI2luY2x1ZGUgIkxheWVyUmVuZGVyZXJDaHJvbWl1bS5oIgogI2luY2x1ZGUgIk5v dGlmaWNhdGlvblByZXNlbnRlckltcGwuaCIKICNpbmNsdWRlICJTcGVlY2hJbnB1dENsaWVudElt cGwuaCIKQEAgLTM4Nyw2ICszODgsNyBAQCBwcml2YXRlOgogI2lmIFVTRShBQ0NFTEVSQVRFRF9D T01QT1NJVElORykKICAgICB2b2lkIHNldElzQWNjZWxlcmF0ZWRDb21wb3NpdGluZ0FjdGl2ZShi b29sKTsKICAgICB2b2lkIHVwZGF0ZVJvb3RMYXllckNvbnRlbnRzKGNvbnN0IFdlYlJlY3QmKTsK KyAgICB2b2lkIGRvUGl4ZWxSZWFkYmFja1RvQ2FudmFzKFdlYkNhbnZhcyosIGNvbnN0IFdlYkNv cmU6OkludFJlY3QmKTsKICNlbmRpZgogCiAgICAgV2ViVmlld0NsaWVudCogbV9jbGllbnQ7Cg== 67085 2010-09-09 13:28:07 -0700 2010-09-10 07:27:17 -0700 Patch bug-44127-20100909162845.patch text/plain 9406 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZGM0Zjc1ODE2OGE2NTViMzE4ZjY4MWE2Yjg1MDQxMzQ5Njg3ZGExOC4uYzMwZDBjOTk4N2U2ZTBm MTdmNGYwZmU0ODI0Zjc3OGVjMjM1YTEyZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOS0wOSAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKyAgICAgICAgQWRkcyBw aXhlbC1yZWFkYmFjayBmb3IgR1BVIGNvbXBvc2l0ZWQgcGFnZXMgdG8gYWxsb3cgZm9yIHRodW1i bmFpbGluZywKKyAgICAgICAgcHJpbnRpbmcgYW5kIG90aGVyIHNlcnZpY2VzIHRvIHdvcmsgd2l0 aCBHUFUgcmVuZGVyZWQgcGFnZXMuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVu ZGVyZXJDaHJvbWl1bTo6cHJlc2VudCk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVy Q2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaDoKKyAgICAgICAgKFdlYkNvcmU6 OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6cm9vdExheWVyVGV4dHVyZVNpemUpOgorCiAyMDEwLTA5 LTA3ICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KIAogICAgICAgICBB ZGQgcmVuZGVyaW5nL0NvbHVtbkluZm8uaCB0byB0aGUgc291cmNlcyBsaXN0LgpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21p dW0uY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVy Q2hyb21pdW0uY3BwCmluZGV4IDc4OTI5OGFlZDhjZTk3NjMwMjBjZmUwYWUyMjQ4ZTM3MzNkZjJj OGMuLmY5NDgyMjg4N2ZhNGI2MTgxM2JkNGRmZGI4YjU5ZTI5ZWViMjI5NzggMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVt LmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVy ZXJDaHJvbWl1bS5jcHAKQEAgLTMyOCwxMSArMzI4LDMwIEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNo cm9taXVtOjpkcmF3TGF5ZXJzKGNvbnN0IEludFJlY3QmIHVwZGF0ZVJlY3QsIGNvbnN0IEludFJl Y3QmCiAKICAgICBHTEMoZ2xEaXNhYmxlKEdMX1NDSVNTT1JfVEVTVCkpOwogCisgICAgZ2xGbHVz aCgpOworfQorCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6cHJlc2VudCgpCit7CiAgICAg bV9nbGVzMkNvbnRleHQtPnN3YXBCdWZmZXJzKCk7CiAKICAgICBtX25lZWRzRGlzcGxheSA9IGZh bHNlOwogfQogCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhl bHModm9pZCAqcGl4ZWxzLCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIEFTU0VSVChyZWN0 LnJpZ2h0KCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUoKS53aWR0aCgpCisgICAgICAgICAgICYm IHJlY3QuYm90dG9tKCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUoKS5oZWlnaHQoKSk7CisKKyAg ICBpZiAoIXBpeGVscykKKyAgICAgICAgcmV0dXJuOworCisgICAgbWFrZUNvbnRleHRDdXJyZW50 KCk7CisKKyAgICBHTEMoZ2xSZWFkUGl4ZWxzKHJlY3QueCgpLCByZWN0LnkoKSwgcmVjdC53aWR0 aCgpLCByZWN0LmhlaWdodCgpLAorICAgICAgICAgICAgICAgICAgICAgR0xfUkdCQSwgR0xfVU5T SUdORURfQllURSwgcGl4ZWxzKSk7Cit9CisKIC8vIEZJWE1FOiBUaGlzIG1ldGhvZCBzaG91bGQg ZXZlbnR1YWxseSBiZSByZXBsYWNlZCBieSBhIHByb3BlciB0ZXh0dXJlIG1hbmFnZXIuCiB1bnNp Z25lZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmNyZWF0ZUxheWVyVGV4dHVyZSgpCiB7CmRpZmYg LS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uaAppbmRleCA4ZjQ0YWZlYmQwYTJjN2I0NzVkMDRiYTQ4NzIzZjFjZGM1NDU1 MDkxLi5mZmU0MTQyM2Q1M2UzZjU0MGU3MTAyMzNmYWYyYTBmODE1NjJjZTU3IDEwMDY0NAotLS0g YS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1 bS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmgKQEAgLTY0LDYgKzY0LDcgQEAgcHVibGljOgogICAgIC8vIFVwZGF0ZXMgdGhl IGNvbnRlbnRzIG9mIHRoZSByb290IGxheWVyIHRoYXQgZmFsbCBpbnNpZGUgdGhlIHVwZGF0ZVJl Y3QgYW5kIHJlY29tcG9zaXRlcwogICAgIC8vIGFsbCB0aGUgbGF5ZXJzLgogICAgIHZvaWQgZHJh d0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0JiB2aXNpYmxl UmVjdCwgY29uc3QgSW50UmVjdCYgY29udGVudFJlY3QsIGNvbnN0IEludFBvaW50JiBzY3JvbGxQ b3NpdGlvbik7CisgICAgdm9pZCBwcmVzZW50KCk7IC8vIFBlcmZvcm0gYnVmZmVyIHN3YXAgdG8g cHJlc2VudCByZW5kZXJlZCBidWZmZXIuCiAKICAgICB2b2lkIHNldFJvb3RMYXllcihQYXNzUmVm UHRyPExheWVyQ2hyb21pdW0+IGxheWVyKSB7IG1fcm9vdExheWVyID0gbGF5ZXI7IH0KICAgICBM YXllckNocm9taXVtKiByb290TGF5ZXIoKSB7IHJldHVybiBtX3Jvb3RMYXllci5nZXQoKTsgfQpA QCAtOTAsNiArOTEsOSBAQCBwdWJsaWM6CiAgICAgY29uc3QgQ29udGVudExheWVyQ2hyb21pdW06 OlNoYXJlZFZhbHVlcyogY29udGVudExheWVyU2hhcmVkVmFsdWVzKCkgY29uc3QgeyByZXR1cm4g bV9jb250ZW50TGF5ZXJTaGFyZWRWYWx1ZXMuZ2V0KCk7IH0KICAgICBjb25zdCBDYW52YXNMYXll ckNocm9taXVtOjpTaGFyZWRWYWx1ZXMqIGNhbnZhc0xheWVyU2hhcmVkVmFsdWVzKCkgY29uc3Qg eyByZXR1cm4gbV9jYW52YXNMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsgfQogCisgICAgSW50U2l6 ZSByb290TGF5ZXJUZXh0dXJlU2l6ZSgpIGNvbnN0IHsgcmV0dXJuIEludFNpemUobV9yb290TGF5 ZXJUZXh0dXJlV2lkdGgsIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCk7IH0KKyAgICB2b2lkIGdl dEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgSW50UmVjdCYgcmVjdCk7CisK IHByaXZhdGU6CiAgICAgdm9pZCB1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5ZXJDaHJvbWl1bSog bGF5ZXIsIGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0cml4JiBwYXJlbnRNYXRyaXgsIGZsb2F0IG9w YWNpdHkpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0 L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCAwMjNlMWQ3OTdiMzExYjc4NjdjZWFlMzNlM2I3OTZj OGU3ODdhMDQ1Li5jY2JhZTNkYjYwMmEyNWY0M2JlMjVhZTcyMWExOTA0MThjMDdiYzVhIDEwMDY0 NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOS0wOSAgVy4gSmFtZXMgTWFjTGVhbiAg PHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5vdCBnZW5lcmF0ZWQgZm9y IEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBNb2RpZmllZCBXZWJWaWV3SW1wbDo6cGFpbnQo KSB0byBkZXRlY3Qgbm9uLW51bGwgY2FudmFzIHBvaW50ZXJzIHdoZW4KKyAgICAgICAgYWNjZWxl cmF0ZWQgY29tcG9zaXRpbmcgaXMgYWN0aXZlLCBhbmQgaW5zdGVhZCBmaWxscyB0aGUgcGl4ZWwg YnVmZmVyCisgICAgICAgIGZyb20gdGhlIEdQVSBmcmFtZWJ1ZmZlci4gSW5jbHVkZXMgcmUtc2Nh bGluZyBzdXBwb3J0IHdoZW4gcHJvdmlkZWQKKyAgICAgICAgY2FudmFzIGRvZXMgbm90IG1hdGNo IHNpemUgb2YgY3VycmVudCByZW5kZXIgbGF5ZXIuIExpbWl0cyBwaXhlbAorICAgICAgICByZWFk YmFjayB0byByZWN0IHBhc3NlZCB0byBwYWludCgpLCBjbGlwcGVkIGJ5IHNpemUgb2Ygcm9vdExh eWVyVGV4dHVyZS4KKworICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYlZpZXdJbXBsOjpkb1BpeGVsUmVhZGJhY2tUb0NhbnZhcyk6CisgICAgICAgIChX ZWJLaXQ6OldlYlZpZXdJbXBsOjpwYWludCk6CisgICAgICAgICogc3JjL1dlYlZpZXdJbXBsLmg6 CisKIDIwMTAtMDktMDcgIERpbWl0cmkgR2xhemtvdiAgPGRnbGF6a292QGNocm9taXVtLm9yZz4K IAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByNjY4ODYuCmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViVmlld0ltcGwuY3BwCmluZGV4IGY2M2M5MDgyNTYyNmNiMDZjYmM2ZjBhNWEzNWYyMjdiYmQ1 YmU3ODIuLjUzYzdhYzBiNjlmNTdiM2ZlMjBlM2VhZmUxYTUwYzNjOWU4MDViOWUgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCkBAIC0zNCw2ICszNCw3IEBACiAjaW5jbHVkZSAiQXV0 b0ZpbGxQb3B1cE1lbnVDbGllbnQuaCIKICNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5j bHVkZSAiQ2hyb21lLmgiCisjaW5jbHVkZSAiQ29sb3JTcGFjZS5oIgogI2luY2x1ZGUgIkNvbXBv c2l0aW9uVW5kZXJsaW5lVmVjdG9yQnVpbGRlci5oIgogI2luY2x1ZGUgIkNvbnRleHRNZW51Lmgi CiAjaW5jbHVkZSAiQ29udGV4dE1lbnVDb250cm9sbGVyLmgiCkBAIC02NCw4ICs2NSw5IEBACiAj aW5jbHVkZSAiSGl0VGVzdFJlc3VsdC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1 ZGUgIkltYWdlLmgiCisjaW5jbHVkZSAiSW1hZ2VCdWZmZXIuaCIKKyNpbmNsdWRlICJJbWFnZURh dGEuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JDb250cm9sbGVyLmgiCi0jaW5jbHVkZSAiSW50UmVj dC5oIgogI2luY2x1ZGUgIktleWJvYXJkQ29kZXMuaCIKICNpbmNsdWRlICJLZXlib2FyZEV2ZW50 LmgiCiAjaW5jbHVkZSAiTUlNRVR5cGVSZWdpc3RyeS5oIgpAQCAtMTE1LDcgKzExNywxMSBAQAog I2luY2x1ZGUgIldlYlN0cmluZy5oIgogI2luY2x1ZGUgIldlYlZlY3Rvci5oIgogI2luY2x1ZGUg IldlYlZpZXdDbGllbnQuaCIKLSNpbmNsdWRlICJ3dGYvT3duUHRyLmgiCisjaW5jbHVkZSA8d3Rm L1JlZlB0ci5oPgorCisjaWYgUExBVEZPUk0oQ0cpCisjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NH Q29udGV4dC5oPgorI2VuZGlmCiAKICNpZiBPUyhXSU5ET1dTKQogI2luY2x1ZGUgIlJlbmRlclRo ZW1lQ2hyb21pdW1XaW4uaCIKQEAgLTk0NCw2ICs5NTAsNDMgQEAgdm9pZCBXZWJWaWV3SW1wbDo6 bGF5b3V0KCkKICAgICB9CiB9CiAKKyNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCit2 b2lkIFdlYlZpZXdJbXBsOjpkb1BpeGVsUmVhZGJhY2tUb0NhbnZhcyhXZWJDYW52YXMqIGNhbnZh cywgY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBBU1NFUlQocmVjdC5yaWdodCgpIDw9IG1f bGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVNpemUoKS53aWR0aCgpCisgICAgICAgICAg ICYmIHJlY3QuYm90dG9tKCkgPD0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlU2l6 ZSgpLmhlaWdodCgpKTsKKworI2lmIFBMQVRGT1JNKFNLSUEpCisgICAgUGxhdGZvcm1Db250ZXh0 U2tpYSBjb250ZXh0KGNhbnZhcyk7CisKKyAgICAvLyBQbGF0Zm9ybUdyYXBoaWNzQ29udGV4dCBp cyBhY3R1YWxseSBhIHBvaW50ZXIgdG8gUGxhdGZvcm1Db250ZXh0U2tpYQorICAgIEdyYXBoaWNz Q29udGV4dCBnYyhyZWludGVycHJldF9jYXN0PFBsYXRmb3JtR3JhcGhpY3NDb250ZXh0Kj4oJmNv bnRleHQpKTsKKyAgICBpbnQgYml0bWFwSGVpZ2h0ID0gY2FudmFzLT5nZXREZXZpY2UoKS0+YWNj ZXNzQml0bWFwKGZhbHNlKS5oZWlnaHQoKTsKKyNlbGlmIFBMQVRGT1JNKENHKQorICAgIEdyYXBo aWNzQ29udGV4dCBnYyhjYW52YXMpOworICAgIGludCBiaXRtYXBIZWlnaHQgPSBDR0JpdG1hcENv bnRleHRHZXRIZWlnaHQocmVpbnRlcnByZXRfY2FzdDxDR0NvbnRleHRSZWY+KGNhbnZhcykpOwor I2Vsc2UKKyAgICBub3RJbXBsZW1lbnRlZCgpOworI2VuZGlmCisgICAgLy8gQ29tcHV0ZSByZWN0 IHRvIHNhbXBsZSBmcm9tIGluIGludmVydGVkIEdQVSBidWZmZXIuCisgICAgSW50UmVjdCBpbnZl cnRSZWN0KHJlY3QueCgpLCBiaXRtYXBIZWlnaHQgLSAocmVjdC55KCkgKyByZWN0LmhlaWdodCgp KSwgcmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpKTsKKworICAgIE93blB0cjxJbWFnZUJ1ZmZl cj4gaW1nQnVmZmVyKEltYWdlQnVmZmVyOjpjcmVhdGUocmVjdC5zaXplKCkpKTsKKyAgICBSZWZQ dHI8SW1hZ2VEYXRhPiBpbWdEYXRhKEltYWdlRGF0YTo6Y3JlYXRlKHJlY3Qud2lkdGgoKSwgcmVj dC5oZWlnaHQoKSkpOworICAgIGlmIChpbWdCdWZmZXIuZ2V0KCkgJiYgaW1nRGF0YS5nZXQoKSkg eworICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdldEZyYW1lYnVmZmVyUGl4ZWxzKGltZ0RhdGEt PmRhdGEoKS0+ZGF0YSgpLT5kYXRhKCksIGludmVydFJlY3QpOworICAgICAgICBpbWdCdWZmZXIt PnB1dFByZW11bHRpcGxpZWRJbWFnZURhdGEoaW1nRGF0YS5nZXQoKSwgSW50UmVjdChJbnRQb2lu dCgpLCByZWN0LnNpemUoKSksIEludFBvaW50KCkpOworICAgICAgICBnYy5zYXZlKCk7CisgICAg ICAgIGdjLnRyYW5zbGF0ZShGbG9hdFNpemUoMC4wZiwgYml0bWFwSGVpZ2h0KSk7CisgICAgICAg IGdjLnNjYWxlKEZsb2F0U2l6ZSgxLjBmLCAtMS4wZikpOworICAgICAgICAvLyBVc2UgaW52ZXJ0 UmVjdCBpbiBuZXh0IGxpbmUsIHNvIHRoYXQgdHJhbnNmb3JtIGFib3ZlIGludmVydHMgaXQgYmFj ayB0bworICAgICAgICAvLyBkZXNpcmVkIGRlc3RpbmF0aW9uIHJlY3QuCisgICAgICAgIGdjLmRy YXdJbWFnZUJ1ZmZlcihpbWdCdWZmZXIuZ2V0KCksIERldmljZUNvbG9yU3BhY2UsIGludmVydFJl Y3QubG9jYXRpb24oKSk7CisgICAgICAgIGdjLnJlc3RvcmUoKTsKKyAgICB9Cit9CisjZW5kaWYK Kwogdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdlYlJl Y3QmIHJlY3QpCiB7CiAKQEAgLTk3Miw2ICsxMDE1LDE3IEBAIHZvaWQgV2ViVmlld0ltcGw6OnBh aW50KFdlYkNhbnZhcyogY2FudmFzLCBjb25zdCBXZWJSZWN0JiByZWN0KQogICAgICAgICAvLyBB c2sgdGhlIGxheWVyIGNvbXBvc2l0b3IgdG8gcmVkcmF3IGFsbCB0aGUgbGF5ZXJzLgogICAgICAg ICBBU1NFUlQobV9sYXllclJlbmRlcmVyLT5oYXJkd2FyZUNvbXBvc2l0aW5nKCkpOwogICAgICAg ICBtX2xheWVyUmVuZGVyZXItPmRyYXdMYXllcnMocmVjdCwgdmlzaWJsZVJlY3QsIGNvbnRlbnRS ZWN0LCBJbnRQb2ludCh2aWV3LT5zY3JvbGxYKCksIHZpZXctPnNjcm9sbFkoKSkpOworCisgICAg ICAgIC8vIElmIGEgY2FudmFzIHdhcyBwYXNzZWQgaW4sIHdlIHVzZSBpdCB0byBncmFiIGEgY29w eSBvZiB0aGUKKyAgICAgICAgLy8gZnJlc2hseS1yZW5kZXJlZCBwaXhlbHMuCisgICAgICAgIGlm IChjYW52YXMpIHsKKyAgICAgICAgICAgIC8vIENsaXAgcmVjdCB0byB0aGUgY29uZmluZXMgb2Yg dGhlIHJvb3RMYXllclRleHR1cmUuCisgICAgICAgICAgICBJbnRSZWN0IHJlc2l6ZVJlY3QocmVj dC54LCByZWN0LnksIHJlY3Qud2lkdGgsIHJlY3QuaGVpZ2h0KTsKKyAgICAgICAgICAgIHJlc2l6 ZVJlY3QuaW50ZXJzZWN0KEludFJlY3QoSW50UG9pbnQoKSwgbV9sYXllclJlbmRlcmVyLT5yb290 TGF5ZXJUZXh0dXJlU2l6ZSgpKSk7CisgICAgICAgICAgICBkb1BpeGVsUmVhZGJhY2tUb0NhbnZh cyhjYW52YXMsIHJlc2l6ZVJlY3QpOworICAgICAgICB9CisKKyAgICAgICAgbV9sYXllclJlbmRl cmVyLT5wcmVzZW50KCk7IC8vIERvIGZpbmFsIGRpc3BsYXkgYnkgc3dhcHBpbmcgYnVmZmVycy4K ICAgICB9CiAjZW5kaWYKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmll d0ltcGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAppbmRleCBhNDIwOTlj OWQ1ZjQ4NDNjMmYzZTQ3ZDc1Mzc3ZDRkNWEwZjdlOWYxLi45OGQyNjdiNTJlMTBlNjRjYzk2OGEz NDZlMGY4MDQyMjhiZTljNWZiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZp ZXdJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBAIC00NSw2 ICs0NSw3IEBACiAjaW5jbHVkZSAiRWRpdG9yQ2xpZW50SW1wbC5oIgogI2luY2x1ZGUgIkdyYXBo aWNzTGF5ZXIuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JDbGllbnRJbXBsLmgiCisjaW5jbHVkZSAi SW50UmVjdC5oIgogI2luY2x1ZGUgIkxheWVyUmVuZGVyZXJDaHJvbWl1bS5oIgogI2luY2x1ZGUg Ik5vdGlmaWNhdGlvblByZXNlbnRlckltcGwuaCIKICNpbmNsdWRlICJTcGVlY2hJbnB1dENsaWVu dEltcGwuaCIKQEAgLTM4Nyw2ICszODgsNyBAQCBwcml2YXRlOgogI2lmIFVTRShBQ0NFTEVSQVRF RF9DT01QT1NJVElORykKICAgICB2b2lkIHNldElzQWNjZWxlcmF0ZWRDb21wb3NpdGluZ0FjdGl2 ZShib29sKTsKICAgICB2b2lkIHVwZGF0ZVJvb3RMYXllckNvbnRlbnRzKGNvbnN0IFdlYlJlY3Qm KTsKKyAgICB2b2lkIGRvUGl4ZWxSZWFkYmFja1RvQ2FudmFzKFdlYkNhbnZhcyosIGNvbnN0IFdl YkNvcmU6OkludFJlY3QmKTsKICNlbmRpZgogCiAgICAgV2ViVmlld0NsaWVudCogbV9jbGllbnQ7 Cg== 67178 2010-09-10 07:27:23 -0700 2010-09-13 09:52:36 -0700 Patch bug-44127-20100910102805.patch text/plain 9390 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZGM0Zjc1ODE2OGE2NTViMzE4ZjY4MWE2Yjg1MDQxMzQ5Njg3ZGExOC4uYzMwZDBjOTk4N2U2ZTBm MTdmNGYwZmU0ODI0Zjc3OGVjMjM1YTEyZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOS0wOSAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5v dCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBSZXBsaWNhdGVzIGV4 aXN0aW5nIGZ1bmN0aW9uYWxpdHksIHVzZSBleGlzdGluZyB0ZXN0cy4KKyAgICAgICAgQWRkcyBw aXhlbC1yZWFkYmFjayBmb3IgR1BVIGNvbXBvc2l0ZWQgcGFnZXMgdG8gYWxsb3cgZm9yIHRodW1i bmFpbGluZywKKyAgICAgICAgcHJpbnRpbmcgYW5kIG90aGVyIHNlcnZpY2VzIHRvIHdvcmsgd2l0 aCBHUFUgcmVuZGVyZWQgcGFnZXMuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJS ZW5kZXJlckNocm9taXVtOjpkcmF3TGF5ZXJzKToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVu ZGVyZXJDaHJvbWl1bTo6cHJlc2VudCk6CisgICAgICAgIChXZWJDb3JlOjpMYXllclJlbmRlcmVy Q2hyb21pdW06OmdldEZyYW1lYnVmZmVyUGl4ZWxzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaDoKKyAgICAgICAgKFdlYkNvcmU6 OkxheWVyUmVuZGVyZXJDaHJvbWl1bTo6cm9vdExheWVyVGV4dHVyZVNpemUpOgorCiAyMDEwLTA5 LTA3ICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KIAogICAgICAgICBB ZGQgcmVuZGVyaW5nL0NvbHVtbkluZm8uaCB0byB0aGUgc291cmNlcyBsaXN0LgpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21p dW0uY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVy Q2hyb21pdW0uY3BwCmluZGV4IDc4OTI5OGFlZDhjZTk3NjMwMjBjZmUwYWUyMjQ4ZTM3MzNkZjJj OGMuLmY5NDgyMjg4N2ZhNGI2MTgxM2JkNGRmZGI4YjU5ZTI5ZWViMjI5NzggMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVt LmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVy ZXJDaHJvbWl1bS5jcHAKQEAgLTMyOCwxMSArMzI4LDMwIEBAIHZvaWQgTGF5ZXJSZW5kZXJlckNo cm9taXVtOjpkcmF3TGF5ZXJzKGNvbnN0IEludFJlY3QmIHVwZGF0ZVJlY3QsIGNvbnN0IEludFJl Y3QmCiAKICAgICBHTEMoZ2xEaXNhYmxlKEdMX1NDSVNTT1JfVEVTVCkpOwogCisgICAgZ2xGbHVz aCgpOworfQorCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6cHJlc2VudCgpCit7CiAgICAg bV9nbGVzMkNvbnRleHQtPnN3YXBCdWZmZXJzKCk7CiAKICAgICBtX25lZWRzRGlzcGxheSA9IGZh bHNlOwogfQogCit2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhl bHModm9pZCAqcGl4ZWxzLCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIEFTU0VSVChyZWN0 LnJpZ2h0KCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUoKS53aWR0aCgpCisgICAgICAgICAgICYm IHJlY3QuYm90dG9tKCkgPD0gcm9vdExheWVyVGV4dHVyZVNpemUoKS5oZWlnaHQoKSk7CisKKyAg ICBpZiAoIXBpeGVscykKKyAgICAgICAgcmV0dXJuOworCisgICAgbWFrZUNvbnRleHRDdXJyZW50 KCk7CisKKyAgICBHTEMoZ2xSZWFkUGl4ZWxzKHJlY3QueCgpLCByZWN0LnkoKSwgcmVjdC53aWR0 aCgpLCByZWN0LmhlaWdodCgpLAorICAgICAgICAgICAgICAgICAgICAgR0xfUkdCQSwgR0xfVU5T SUdORURfQllURSwgcGl4ZWxzKSk7Cit9CisKIC8vIEZJWE1FOiBUaGlzIG1ldGhvZCBzaG91bGQg ZXZlbnR1YWxseSBiZSByZXBsYWNlZCBieSBhIHByb3BlciB0ZXh0dXJlIG1hbmFnZXIuCiB1bnNp Z25lZCBMYXllclJlbmRlcmVyQ2hyb21pdW06OmNyZWF0ZUxheWVyVGV4dHVyZSgpCiB7CmRpZmYg LS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJD aHJvbWl1bS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclJlbmRl cmVyQ2hyb21pdW0uaAppbmRleCA4ZjQ0YWZlYmQwYTJjN2I0NzVkMDRiYTQ4NzIzZjFjZGM1NDU1 MDkxLi5mZmU0MTQyM2Q1M2UzZjU0MGU3MTAyMzNmYWYyYTBmODE1NjJjZTU3IDEwMDY0NAotLS0g YS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1 bS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJl ckNocm9taXVtLmgKQEAgLTY0LDYgKzY0LDcgQEAgcHVibGljOgogICAgIC8vIFVwZGF0ZXMgdGhl IGNvbnRlbnRzIG9mIHRoZSByb290IGxheWVyIHRoYXQgZmFsbCBpbnNpZGUgdGhlIHVwZGF0ZVJl Y3QgYW5kIHJlY29tcG9zaXRlcwogICAgIC8vIGFsbCB0aGUgbGF5ZXJzLgogICAgIHZvaWQgZHJh d0xheWVycyhjb25zdCBJbnRSZWN0JiB1cGRhdGVSZWN0LCBjb25zdCBJbnRSZWN0JiB2aXNpYmxl UmVjdCwgY29uc3QgSW50UmVjdCYgY29udGVudFJlY3QsIGNvbnN0IEludFBvaW50JiBzY3JvbGxQ b3NpdGlvbik7CisgICAgdm9pZCBwcmVzZW50KCk7IC8vIFBlcmZvcm0gYnVmZmVyIHN3YXAgdG8g cHJlc2VudCByZW5kZXJlZCBidWZmZXIuCiAKICAgICB2b2lkIHNldFJvb3RMYXllcihQYXNzUmVm UHRyPExheWVyQ2hyb21pdW0+IGxheWVyKSB7IG1fcm9vdExheWVyID0gbGF5ZXI7IH0KICAgICBM YXllckNocm9taXVtKiByb290TGF5ZXIoKSB7IHJldHVybiBtX3Jvb3RMYXllci5nZXQoKTsgfQpA QCAtOTAsNiArOTEsOSBAQCBwdWJsaWM6CiAgICAgY29uc3QgQ29udGVudExheWVyQ2hyb21pdW06 OlNoYXJlZFZhbHVlcyogY29udGVudExheWVyU2hhcmVkVmFsdWVzKCkgY29uc3QgeyByZXR1cm4g bV9jb250ZW50TGF5ZXJTaGFyZWRWYWx1ZXMuZ2V0KCk7IH0KICAgICBjb25zdCBDYW52YXNMYXll ckNocm9taXVtOjpTaGFyZWRWYWx1ZXMqIGNhbnZhc0xheWVyU2hhcmVkVmFsdWVzKCkgY29uc3Qg eyByZXR1cm4gbV9jYW52YXNMYXllclNoYXJlZFZhbHVlcy5nZXQoKTsgfQogCisgICAgSW50U2l6 ZSByb290TGF5ZXJUZXh0dXJlU2l6ZSgpIGNvbnN0IHsgcmV0dXJuIEludFNpemUobV9yb290TGF5 ZXJUZXh0dXJlV2lkdGgsIG1fcm9vdExheWVyVGV4dHVyZUhlaWdodCk7IH0KKyAgICB2b2lkIGdl dEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgSW50UmVjdCYgcmVjdCk7CisK IHByaXZhdGU6CiAgICAgdm9pZCB1cGRhdGVMYXllcnNSZWN1cnNpdmUoTGF5ZXJDaHJvbWl1bSog bGF5ZXIsIGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0cml4JiBwYXJlbnRNYXRyaXgsIGZsb2F0IG9w YWNpdHkpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0 L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCAwMjNlMWQ3OTdiMzExYjc4NjdjZWFlMzNlM2I3OTZj OGU3ODdhMDQ1Li5jY2JhZTNkYjYwMmEyNWY0M2JlMjVhZTcyMWExOTA0MThjMDdiYzVhIDEwMDY0 NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOS0wOSAgVy4gSmFtZXMgTWFjTGVhbiAg PHdqbWFjbGVhbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBUaHVtYm5haWxzIG5vdCBnZW5lcmF0ZWQgZm9y IEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAgICBNb2RpZmllZCBXZWJWaWV3SW1wbDo6cGFpbnQo KSB0byBkZXRlY3Qgbm9uLW51bGwgY2FudmFzIHBvaW50ZXJzIHdoZW4KKyAgICAgICAgYWNjZWxl cmF0ZWQgY29tcG9zaXRpbmcgaXMgYWN0aXZlLCBhbmQgaW5zdGVhZCBmaWxscyB0aGUgcGl4ZWwg YnVmZmVyCisgICAgICAgIGZyb20gdGhlIEdQVSBmcmFtZWJ1ZmZlci4gSW5jbHVkZXMgcmUtc2Nh bGluZyBzdXBwb3J0IHdoZW4gcHJvdmlkZWQKKyAgICAgICAgY2FudmFzIGRvZXMgbm90IG1hdGNo IHNpemUgb2YgY3VycmVudCByZW5kZXIgbGF5ZXIuIExpbWl0cyBwaXhlbAorICAgICAgICByZWFk YmFjayB0byByZWN0IHBhc3NlZCB0byBwYWludCgpLCBjbGlwcGVkIGJ5IHNpemUgb2Ygcm9vdExh eWVyVGV4dHVyZS4KKworICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYlZpZXdJbXBsOjpkb1BpeGVsUmVhZGJhY2tUb0NhbnZhcyk6CisgICAgICAgIChX ZWJLaXQ6OldlYlZpZXdJbXBsOjpwYWludCk6CisgICAgICAgICogc3JjL1dlYlZpZXdJbXBsLmg6 CisKIDIwMTAtMDktMDcgIERpbWl0cmkgR2xhemtvdiAgPGRnbGF6a292QGNocm9taXVtLm9yZz4K IAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByNjY4ODYuCmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViVmlld0ltcGwuY3BwCmluZGV4IGY2M2M5MDgyNTYyNmNiMDZjYmM2ZjBhNWEzNWYyMjdiYmQ1 YmU3ODIuLmNlN2I3MTRiYTI4NGNmM2U5MTQ5ZGVjMzdmNmU4MjU5NWJlNzFmY2EgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCkBAIC0zNCw2ICszNCw3IEBACiAjaW5jbHVkZSAiQXV0 b0ZpbGxQb3B1cE1lbnVDbGllbnQuaCIKICNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5j bHVkZSAiQ2hyb21lLmgiCisjaW5jbHVkZSAiQ29sb3JTcGFjZS5oIgogI2luY2x1ZGUgIkNvbXBv c2l0aW9uVW5kZXJsaW5lVmVjdG9yQnVpbGRlci5oIgogI2luY2x1ZGUgIkNvbnRleHRNZW51Lmgi CiAjaW5jbHVkZSAiQ29udGV4dE1lbnVDb250cm9sbGVyLmgiCkBAIC02NCw4ICs2NSw5IEBACiAj aW5jbHVkZSAiSGl0VGVzdFJlc3VsdC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1 ZGUgIkltYWdlLmgiCisjaW5jbHVkZSAiSW1hZ2VCdWZmZXIuaCIKKyNpbmNsdWRlICJJbWFnZURh dGEuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JDb250cm9sbGVyLmgiCi0jaW5jbHVkZSAiSW50UmVj dC5oIgogI2luY2x1ZGUgIktleWJvYXJkQ29kZXMuaCIKICNpbmNsdWRlICJLZXlib2FyZEV2ZW50 LmgiCiAjaW5jbHVkZSAiTUlNRVR5cGVSZWdpc3RyeS5oIgpAQCAtMTE1LDcgKzExNywxMSBAQAog I2luY2x1ZGUgIldlYlN0cmluZy5oIgogI2luY2x1ZGUgIldlYlZlY3Rvci5oIgogI2luY2x1ZGUg IldlYlZpZXdDbGllbnQuaCIKLSNpbmNsdWRlICJ3dGYvT3duUHRyLmgiCisjaW5jbHVkZSA8d3Rm L1JlZlB0ci5oPgorCisjaWYgUExBVEZPUk0oQ0cpCisjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NH Q29udGV4dC5oPgorI2VuZGlmCiAKICNpZiBPUyhXSU5ET1dTKQogI2luY2x1ZGUgIlJlbmRlclRo ZW1lQ2hyb21pdW1XaW4uaCIKQEAgLTk0NCw2ICs5NTAsNDMgQEAgdm9pZCBXZWJWaWV3SW1wbDo6 bGF5b3V0KCkKICAgICB9CiB9CiAKKyNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCit2 b2lkIFdlYlZpZXdJbXBsOjpkb1BpeGVsUmVhZGJhY2tUb0NhbnZhcyhXZWJDYW52YXMqIGNhbnZh cywgY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBBU1NFUlQocmVjdC5yaWdodCgpIDw9IG1f bGF5ZXJSZW5kZXJlci0+cm9vdExheWVyVGV4dHVyZVNpemUoKS53aWR0aCgpCisgICAgICAgICAg ICYmIHJlY3QuYm90dG9tKCkgPD0gbV9sYXllclJlbmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlU2l6 ZSgpLmhlaWdodCgpKTsKKworI2lmIFBMQVRGT1JNKFNLSUEpCisgICAgUGxhdGZvcm1Db250ZXh0 U2tpYSBjb250ZXh0KGNhbnZhcyk7CisKKyAgICAvLyBQbGF0Zm9ybUdyYXBoaWNzQ29udGV4dCBp cyBhY3R1YWxseSBhIHBvaW50ZXIgdG8gUGxhdGZvcm1Db250ZXh0U2tpYQorICAgIEdyYXBoaWNz Q29udGV4dCBnYyhyZWludGVycHJldF9jYXN0PFBsYXRmb3JtR3JhcGhpY3NDb250ZXh0Kj4oJmNv bnRleHQpKTsKKyAgICBpbnQgYml0bWFwSGVpZ2h0ID0gY2FudmFzLT5nZXREZXZpY2UoKS0+YWNj ZXNzQml0bWFwKGZhbHNlKS5oZWlnaHQoKTsKKyNlbGlmIFBMQVRGT1JNKENHKQorICAgIEdyYXBo aWNzQ29udGV4dCBnYyhjYW52YXMpOworICAgIGludCBiaXRtYXBIZWlnaHQgPSBDR0JpdG1hcENv bnRleHRHZXRIZWlnaHQocmVpbnRlcnByZXRfY2FzdDxDR0NvbnRleHRSZWY+KGNhbnZhcykpOwor I2Vsc2UKKyAgICBub3RJbXBsZW1lbnRlZCgpOworI2VuZGlmCisgICAgLy8gQ29tcHV0ZSByZWN0 IHRvIHNhbXBsZSBmcm9tIGludmVydGVkIEdQVSBidWZmZXIuCisgICAgSW50UmVjdCBpbnZlcnRS ZWN0KHJlY3QueCgpLCBiaXRtYXBIZWlnaHQgLSByZWN0LmJvdHRvbSgpLCByZWN0LndpZHRoKCks IHJlY3QuaGVpZ2h0KCkpOworCisgICAgT3duUHRyPEltYWdlQnVmZmVyPiBpbWdCdWZmZXIoSW1h Z2VCdWZmZXI6OmNyZWF0ZShyZWN0LnNpemUoKSkpOworICAgIFJlZlB0cjxJbWFnZURhdGE+IGlt Z0RhdGEoSW1hZ2VEYXRhOjpjcmVhdGUocmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpKSk7Cisg ICAgaWYgKGltZ0J1ZmZlci5nZXQoKSAmJiBpbWdEYXRhLmdldCgpKSB7CisgICAgICAgIG1fbGF5 ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhlbHMoaW1nRGF0YS0+ZGF0YSgpLT5kYXRhKCkt PmRhdGEoKSwgaW52ZXJ0UmVjdCk7CisgICAgICAgIGltZ0J1ZmZlci0+cHV0UHJlbXVsdGlwbGll ZEltYWdlRGF0YShpbWdEYXRhLmdldCgpLCBJbnRSZWN0KEludFBvaW50KCksIHJlY3Quc2l6ZSgp KSwgSW50UG9pbnQoKSk7CisgICAgICAgIGdjLnNhdmUoKTsKKyAgICAgICAgZ2MudHJhbnNsYXRl KEZsb2F0U2l6ZSgwLjBmLCBiaXRtYXBIZWlnaHQpKTsKKyAgICAgICAgZ2Muc2NhbGUoRmxvYXRT aXplKDEuMGYsIC0xLjBmKSk7CisgICAgICAgIC8vIFVzZSBpbnZlcnRSZWN0IGluIG5leHQgbGlu ZSwgc28gdGhhdCB0cmFuc2Zvcm0gYWJvdmUgaW52ZXJ0cyBpdCBiYWNrIHRvCisgICAgICAgIC8v IGRlc2lyZWQgZGVzdGluYXRpb24gcmVjdC4KKyAgICAgICAgZ2MuZHJhd0ltYWdlQnVmZmVyKGlt Z0J1ZmZlci5nZXQoKSwgRGV2aWNlQ29sb3JTcGFjZSwgaW52ZXJ0UmVjdC5sb2NhdGlvbigpKTsK KyAgICAgICAgZ2MucmVzdG9yZSgpOworICAgIH0KK30KKyNlbmRpZgorCiB2b2lkIFdlYlZpZXdJ bXBsOjpwYWludChXZWJDYW52YXMqIGNhbnZhcywgY29uc3QgV2ViUmVjdCYgcmVjdCkKIHsKIApA QCAtOTcyLDYgKzEwMTUsMTcgQEAgdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBj YW52YXMsIGNvbnN0IFdlYlJlY3QmIHJlY3QpCiAgICAgICAgIC8vIEFzayB0aGUgbGF5ZXIgY29t cG9zaXRvciB0byByZWRyYXcgYWxsIHRoZSBsYXllcnMuCiAgICAgICAgIEFTU0VSVChtX2xheWVy UmVuZGVyZXItPmhhcmR3YXJlQ29tcG9zaXRpbmcoKSk7CiAgICAgICAgIG1fbGF5ZXJSZW5kZXJl ci0+ZHJhd0xheWVycyhyZWN0LCB2aXNpYmxlUmVjdCwgY29udGVudFJlY3QsIEludFBvaW50KHZp ZXctPnNjcm9sbFgoKSwgdmlldy0+c2Nyb2xsWSgpKSk7CisKKyAgICAgICAgLy8gSWYgYSBjYW52 YXMgd2FzIHBhc3NlZCBpbiwgd2UgdXNlIGl0IHRvIGdyYWIgYSBjb3B5IG9mIHRoZQorICAgICAg ICAvLyBmcmVzaGx5LXJlbmRlcmVkIHBpeGVscy4KKyAgICAgICAgaWYgKGNhbnZhcykgeworICAg ICAgICAgICAgLy8gQ2xpcCByZWN0IHRvIHRoZSBjb25maW5lcyBvZiB0aGUgcm9vdExheWVyVGV4 dHVyZS4KKyAgICAgICAgICAgIEludFJlY3QgcmVzaXplUmVjdChyZWN0LngsIHJlY3QueSwgcmVj dC53aWR0aCwgcmVjdC5oZWlnaHQpOworICAgICAgICAgICAgcmVzaXplUmVjdC5pbnRlcnNlY3Qo SW50UmVjdChJbnRQb2ludCgpLCBtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVTaXpl KCkpKTsKKyAgICAgICAgICAgIGRvUGl4ZWxSZWFkYmFja1RvQ2FudmFzKGNhbnZhcywgcmVzaXpl UmVjdCk7CisgICAgICAgIH0KKworICAgICAgICBtX2xheWVyUmVuZGVyZXItPnByZXNlbnQoKTsg Ly8gRG8gZmluYWwgZGlzcGxheSBieSBzd2FwcGluZyBidWZmZXJzLgogICAgIH0KICNlbmRpZgog fQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oIGIvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCmluZGV4IGE0MjA5OWM5ZDVmNDg0M2MyZjNlNDdk NzUzNzdkNGQ1YTBmN2U5ZjEuLjk4ZDI2N2I1MmUxMGU2NGNjOTY4YTM0NmUwZjgwNDIyOGJlOWM1 ZmIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAorKysgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKQEAgLTQ1LDYgKzQ1LDcgQEAKICNpbmNs dWRlICJFZGl0b3JDbGllbnRJbXBsLmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NMYXllci5oIgogI2lu Y2x1ZGUgIkluc3BlY3RvckNsaWVudEltcGwuaCIKKyNpbmNsdWRlICJJbnRSZWN0LmgiCiAjaW5j bHVkZSAiTGF5ZXJSZW5kZXJlckNocm9taXVtLmgiCiAjaW5jbHVkZSAiTm90aWZpY2F0aW9uUHJl c2VudGVySW1wbC5oIgogI2luY2x1ZGUgIlNwZWVjaElucHV0Q2xpZW50SW1wbC5oIgpAQCAtMzg3 LDYgKzM4OCw3IEBAIHByaXZhdGU6CiAjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQog ICAgIHZvaWQgc2V0SXNBY2NlbGVyYXRlZENvbXBvc2l0aW5nQWN0aXZlKGJvb2wpOwogICAgIHZv aWQgdXBkYXRlUm9vdExheWVyQ29udGVudHMoY29uc3QgV2ViUmVjdCYpOworICAgIHZvaWQgZG9Q aXhlbFJlYWRiYWNrVG9DYW52YXMoV2ViQ2FudmFzKiwgY29uc3QgV2ViQ29yZTo6SW50UmVjdCYp OwogI2VuZGlmCiAKICAgICBXZWJWaWV3Q2xpZW50KiBtX2NsaWVudDsK 67419 2010-09-13 09:52:42 -0700 2010-09-13 11:46:34 -0700 Patch bug-44127-20100913125341.patch text/plain 8533 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MWIxNjQyNjg2MTI4NTBlOTE0YmEwYWNhYmQ1NWE0MzhhMGFhNjMwMS4uMzJmODg2YzI0MzgwN2Qz ZDBkMjhhYjdjZTZhNDI5NmVmZGMzYWJmMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMC0wOS0xMyAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVGh1bWJuYWlscyBub3Qg Z2VuZXJhdGVkIGZvciBHUFUgUmVuZGVyZWQgUGFnZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0MTI3CisKKyAgICAgICAgUmVwbGljYXRlcyBleGlz dGluZyBmdW5jdGlvbmFsaXR5LCB1c2UgZXhpc3RpbmcgdGVzdHMuCisgICAgICAgIEFkZHMgcGl4 ZWwtcmVhZGJhY2sgZm9yIEdQVSBjb21wb3NpdGVkIHBhZ2VzIHRvIGFsbG93IGZvciB0aHVtYm5h aWxpbmcsCisgICAgICAgIHByaW50aW5nIGFuZCBvdGhlciBzZXJ2aWNlcyB0byB3b3JrIHdpdGgg R1BVIHJlbmRlcmVkIHBhZ2VzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVu ZGVyZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2Vi Q29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlU2l6ZSk6CisKIDIw MTAtMDktMTMgIEpvbmF0aGFuIERpeG9uICA8am90aEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgU3RldmUgQmxvY2suCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAgYi9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKaW5kZXggODk2 MDg0MTMwOTA0MjM5YTE4NmIyMDc5YjEwN2JkZjdkMzFjYTEzMC4uNTFjMGU0OTE4OWQ5NDdkOTIw ODliNWMyYWM2OTU3NTZiNzk4ZmUwNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCisrKyBiL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcApAQCAtMzU2 LDYgKzM1NiwyMCBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6cHJlc2VudCgpCiAgICAg bV9uZWVkc0Rpc3BsYXkgPSBmYWxzZTsKIH0KIAordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06 OmdldEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgSW50UmVjdCYgcmVjdCkK K3sKKyAgICBBU1NFUlQocmVjdC5yaWdodCgpIDw9IHJvb3RMYXllclRleHR1cmVTaXplKCkud2lk dGgoKQorICAgICAgICAgICAmJiByZWN0LmJvdHRvbSgpIDw9IHJvb3RMYXllclRleHR1cmVTaXpl KCkuaGVpZ2h0KCkpOworCisgICAgaWYgKCFwaXhlbHMpCisgICAgICAgIHJldHVybjsKKworICAg IG1ha2VDb250ZXh0Q3VycmVudCgpOworCisgICAgR0xDKGdsUmVhZFBpeGVscyhyZWN0LngoKSwg cmVjdC55KCksIHJlY3Qud2lkdGgoKSwgcmVjdC5oZWlnaHQoKSwKKyAgICAgICAgICAgICAgICAg ICAgIEdMX1JHQkEsIEdMX1VOU0lHTkVEX0JZVEUsIHBpeGVscykpOworfQorCiAvLyBGSVhNRTog VGhpcyBtZXRob2Qgc2hvdWxkIGV2ZW50dWFsbHkgYmUgcmVwbGFjZWQgYnkgYSBwcm9wZXIgdGV4 dHVyZSBtYW5hZ2VyLgogdW5zaWduZWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpjcmVhdGVMYXll clRleHR1cmUoKQogewpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggMjc0ODE1ZjNmZTIzYzNiMDc4 YzQ3MDNlODQ1YjNiYmM4YzMzZWNiZC4uYjQ1NzRiMjgwYjBmMGNiOTE4ODVkNGRiOWRiNzQyNTIw YTAyNjA3MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXllclJlbmRlcmVyQ2hyb21pdW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC05OCw2ICs5OCw5IEBAIHB1YmxpYzoK ICAgICBjb25zdCBDb250ZW50TGF5ZXJDaHJvbWl1bTo6U2hhcmVkVmFsdWVzKiBjb250ZW50TGF5 ZXJTaGFyZWRWYWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NvbnRlbnRMYXllclNoYXJlZFZhbHVl cy5nZXQoKTsgfQogICAgIGNvbnN0IENhbnZhc0xheWVyQ2hyb21pdW06OlNoYXJlZFZhbHVlcyog Y2FudmFzTGF5ZXJTaGFyZWRWYWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NhbnZhc0xheWVyU2hh cmVkVmFsdWVzLmdldCgpOyB9CiAKKyAgICBJbnRTaXplIHJvb3RMYXllclRleHR1cmVTaXplKCkg Y29uc3QgeyByZXR1cm4gSW50U2l6ZShtX3Jvb3RMYXllclRleHR1cmVXaWR0aCwgbV9yb290TGF5 ZXJUZXh0dXJlSGVpZ2h0KTsgfQorICAgIHZvaWQgZ2V0RnJhbWVidWZmZXJQaXhlbHModm9pZCAq cGl4ZWxzLCBjb25zdCBJbnRSZWN0JiByZWN0KTsKKwogcHJpdmF0ZToKICAgICB2b2lkIHVwZGF0 ZUxheWVyc1JlY3Vyc2l2ZShMYXllckNocm9taXVtKiBsYXllciwgY29uc3QgVHJhbnNmb3JtYXRp b25NYXRyaXgmIHBhcmVudE1hdHJpeCwgZmxvYXQgb3BhY2l0eSk7CiAKZGlmZiAtLWdpdCBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDUzYzE2YzhmYWY2ODMyOTAwNzM2YmU4NzQyZDMzNWU1ZDk3ZTg4Y2MuLjNjZTNlMWQyMDZjOGVh ZWRjMWU1NTJjNzQ5ZTU4OGM2ODI3OWM1YWMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBA CisyMDEwLTA5LTEzICBXLiBKYW1lcyBNYWNMZWFuICA8d2ptYWNsZWFuQGdvb2dsZS5jb20+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVt XSBUaHVtYm5haWxzIG5vdCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAg ICBNb2RpZmllZCBXZWJWaWV3SW1wbDo6cGFpbnQoKSB0byBkZXRlY3Qgbm9uLW51bGwgY2FudmFz IHBvaW50ZXJzIHdoZW4KKyAgICAgICAgYWNjZWxlcmF0ZWQgY29tcG9zaXRpbmcgaXMgYWN0aXZl LCBhbmQgaW5zdGVhZCBmaWxscyB0aGUgcGl4ZWwgYnVmZmVyCisgICAgICAgIGZyb20gdGhlIEdQ VSBmcmFtZWJ1ZmZlci4gSW5jbHVkZXMgcmUtc2NhbGluZyBzdXBwb3J0IHdoZW4gcHJvdmlkZWQK KyAgICAgICAgY2FudmFzIGRvZXMgbm90IG1hdGNoIHNpemUgb2YgY3VycmVudCByZW5kZXIgbGF5 ZXIuIExpbWl0cyBwaXhlbAorICAgICAgICByZWFkYmFjayB0byByZWN0IHBhc3NlZCB0byBwYWlu dCgpLCBjbGlwcGVkIGJ5IHNpemUgb2Ygcm9vdExheWVyVGV4dHVyZS4KKworICAgICAgICAqIHNy Yy9XZWJWaWV3SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBsOjpkb1BpeGVs UmVhZGJhY2tUb0NhbnZhcyk6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBsOjpwYWludCk6 CisgICAgICAgICogc3JjL1dlYlZpZXdJbXBsLmg6CisKIDIwMTAtMDktMTMgIEpvbmF0aGFuIERp eG9uICA8am90aEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU3RldmUgQmxv Y2suCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcCBiL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4IDA0M2UzMjhhM2NiZTZlM2Y1 Yzc4NzM1MjI1ODgxMGFjYjU2MDljMTUuLjkwMjU3OWZiNDZlYWQ4YjYzMWY5NzkyMDE4OThmNTM5 MTBiNDYxNmIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3Bw CisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCkBAIC0zNCw2ICszNCw3 IEBACiAjaW5jbHVkZSAiQXV0b0ZpbGxQb3B1cE1lbnVDbGllbnQuaCIKICNpbmNsdWRlICJBWE9i amVjdENhY2hlLmgiCiAjaW5jbHVkZSAiQ2hyb21lLmgiCisjaW5jbHVkZSAiQ29sb3JTcGFjZS5o IgogI2luY2x1ZGUgIkNvbXBvc2l0aW9uVW5kZXJsaW5lVmVjdG9yQnVpbGRlci5oIgogI2luY2x1 ZGUgIkNvbnRleHRNZW51LmgiCiAjaW5jbHVkZSAiQ29udGV4dE1lbnVDb250cm9sbGVyLmgiCkBA IC02NCw4ICs2NSw5IEBACiAjaW5jbHVkZSAiSGl0VGVzdFJlc3VsdC5oIgogI2luY2x1ZGUgIkhU TUxOYW1lcy5oIgogI2luY2x1ZGUgIkltYWdlLmgiCisjaW5jbHVkZSAiSW1hZ2VCdWZmZXIuaCIK KyNpbmNsdWRlICJJbWFnZURhdGEuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JDb250cm9sbGVyLmgi Ci0jaW5jbHVkZSAiSW50UmVjdC5oIgogI2luY2x1ZGUgIktleWJvYXJkQ29kZXMuaCIKICNpbmNs dWRlICJLZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiTUlNRVR5cGVSZWdpc3RyeS5oIgpAQCAt MTE1LDcgKzExNywxMSBAQAogI2luY2x1ZGUgIldlYlN0cmluZy5oIgogI2luY2x1ZGUgIldlYlZl Y3Rvci5oIgogI2luY2x1ZGUgIldlYlZpZXdDbGllbnQuaCIKLSNpbmNsdWRlICJ3dGYvT3duUHRy LmgiCisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorCisjaWYgUExBVEZPUk0oQ0cpCisjaW5jbHVk ZSA8Q29yZUdyYXBoaWNzL0NHQ29udGV4dC5oPgorI2VuZGlmCiAKICNpZiBPUyhXSU5ET1dTKQog I2luY2x1ZGUgIlJlbmRlclRoZW1lQ2hyb21pdW1XaW4uaCIKQEAgLTk1MCwxNCArOTU2LDU3IEBA IHZvaWQgV2ViVmlld0ltcGw6OmxheW91dCgpCiAgICAgfQogfQogCisjaWYgVVNFKEFDQ0VMRVJB VEVEX0NPTVBPU0lUSU5HKQordm9pZCBXZWJWaWV3SW1wbDo6ZG9QaXhlbFJlYWRiYWNrVG9DYW52 YXMoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgQVNTRVJU KHJlY3QucmlnaHQoKSA8PSBtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVTaXplKCku d2lkdGgoKQorICAgICAgICAgICAmJiByZWN0LmJvdHRvbSgpIDw9IG1fbGF5ZXJSZW5kZXJlci0+ cm9vdExheWVyVGV4dHVyZVNpemUoKS5oZWlnaHQoKSk7CisKKyNpZiBQTEFURk9STShTS0lBKQor ICAgIFBsYXRmb3JtQ29udGV4dFNraWEgY29udGV4dChjYW52YXMpOworCisgICAgLy8gUGxhdGZv cm1HcmFwaGljc0NvbnRleHQgaXMgYWN0dWFsbHkgYSBwb2ludGVyIHRvIFBsYXRmb3JtQ29udGV4 dFNraWEKKyAgICBHcmFwaGljc0NvbnRleHQgZ2MocmVpbnRlcnByZXRfY2FzdDxQbGF0Zm9ybUdy YXBoaWNzQ29udGV4dCo+KCZjb250ZXh0KSk7CisgICAgaW50IGJpdG1hcEhlaWdodCA9IGNhbnZh cy0+Z2V0RGV2aWNlKCktPmFjY2Vzc0JpdG1hcChmYWxzZSkuaGVpZ2h0KCk7CisjZWxpZiBQTEFU Rk9STShDRykKKyAgICBHcmFwaGljc0NvbnRleHQgZ2MoY2FudmFzKTsKKyAgICBpbnQgYml0bWFw SGVpZ2h0ID0gQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KHJlaW50ZXJwcmV0X2Nhc3Q8Q0dDb250 ZXh0UmVmPihjYW52YXMpKTsKKyNlbHNlCisgICAgbm90SW1wbGVtZW50ZWQoKTsKKyNlbmRpZgor ICAgIC8vIENvbXB1dGUgcmVjdCB0byBzYW1wbGUgZnJvbSBpbnZlcnRlZCBHUFUgYnVmZmVyLgor ICAgIEludFJlY3QgaW52ZXJ0UmVjdChyZWN0LngoKSwgYml0bWFwSGVpZ2h0IC0gcmVjdC5ib3R0 b20oKSwgcmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpKTsKKworICAgIE93blB0cjxJbWFnZUJ1 ZmZlcj4gaW1nQnVmZmVyKEltYWdlQnVmZmVyOjpjcmVhdGUocmVjdC5zaXplKCkpKTsKKyAgICBS ZWZQdHI8SW1hZ2VEYXRhPiBpbWdEYXRhKEltYWdlRGF0YTo6Y3JlYXRlKHJlY3Qud2lkdGgoKSwg cmVjdC5oZWlnaHQoKSkpOworICAgIGlmIChpbWdCdWZmZXIuZ2V0KCkgJiYgaW1nRGF0YS5nZXQo KSkgeworICAgICAgICBtX2xheWVyUmVuZGVyZXItPmdldEZyYW1lYnVmZmVyUGl4ZWxzKGltZ0Rh dGEtPmRhdGEoKS0+ZGF0YSgpLT5kYXRhKCksIGludmVydFJlY3QpOworICAgICAgICBpbWdCdWZm ZXItPnB1dFByZW11bHRpcGxpZWRJbWFnZURhdGEoaW1nRGF0YS5nZXQoKSwgSW50UmVjdChJbnRQ b2ludCgpLCByZWN0LnNpemUoKSksIEludFBvaW50KCkpOworICAgICAgICBnYy5zYXZlKCk7Cisg ICAgICAgIGdjLnRyYW5zbGF0ZShGbG9hdFNpemUoMC4wZiwgYml0bWFwSGVpZ2h0KSk7CisgICAg ICAgIGdjLnNjYWxlKEZsb2F0U2l6ZSgxLjBmLCAtMS4wZikpOworICAgICAgICAvLyBVc2UgaW52 ZXJ0UmVjdCBpbiBuZXh0IGxpbmUsIHNvIHRoYXQgdHJhbnNmb3JtIGFib3ZlIGludmVydHMgaXQg YmFjayB0bworICAgICAgICAvLyBkZXNpcmVkIGRlc3RpbmF0aW9uIHJlY3QuCisgICAgICAgIGdj LmRyYXdJbWFnZUJ1ZmZlcihpbWdCdWZmZXIuZ2V0KCksIERldmljZUNvbG9yU3BhY2UsIGludmVy dFJlY3QubG9jYXRpb24oKSk7CisgICAgICAgIGdjLnJlc3RvcmUoKTsKKyAgICB9Cit9CisjZW5k aWYKKwogdm9pZCBXZWJWaWV3SW1wbDo6cGFpbnQoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IFdl YlJlY3QmIHJlY3QpCiB7CiAgICAgaWYgKGlzQWNjZWxlcmF0ZWRDb21wb3NpdGluZ0FjdGl2ZSgp KSB7CiAjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQogICAgICAgICBkb0NvbXBvc2l0 ZSgpOwogCi0gICAgICAgIC8vIFJlYWRiYWNrIGludG8gdGhlIGNhbnZhcwotICAgICAgICAvLyBG SVhNRSBJbnNlcnQgd2ptYWNsZWFuJ3MgcmVhZGJhY2sgY29kZSBoZXJlIGZvciB3ZWJraXQgYnVn IDQ0MTI3CisgICAgICAgIC8vIElmIGEgY2FudmFzIHdhcyBwYXNzZWQgaW4sIHdlIHVzZSBpdCB0 byBncmFiIGEgY29weSBvZiB0aGUKKyAgICAgICAgLy8gZnJlc2hseS1yZW5kZXJlZCBwaXhlbHMu CisgICAgICAgIGlmIChjYW52YXMpIHsKKyAgICAgICAgICAgIC8vIENsaXAgcmVjdCB0byB0aGUg Y29uZmluZXMgb2YgdGhlIHJvb3RMYXllclRleHR1cmUuCisgICAgICAgICAgICBJbnRSZWN0IHJl c2l6ZVJlY3QocmVjdC54LCByZWN0LnksIHJlY3Qud2lkdGgsIHJlY3QuaGVpZ2h0KTsKKyAgICAg ICAgICAgIHJlc2l6ZVJlY3QuaW50ZXJzZWN0KEludFJlY3QoSW50UG9pbnQoKSwgbV9sYXllclJl bmRlcmVyLT5yb290TGF5ZXJUZXh0dXJlU2l6ZSgpKSk7CisgICAgICAgICAgICBkb1BpeGVsUmVh ZGJhY2tUb0NhbnZhcyhjYW52YXMsIHJlc2l6ZVJlY3QpOworICAgICAgICB9CiAKICAgICAgICAg Ly8gVGVtcG9yYXJpbHkgcHJlc2VudCBzbyB0aGUgZG93bnN0cmVhbSBDaHJvbWl1bSByZW5kZXJ3 aWRnZXQgc3RpbGwgcmVuZGVycy4KICAgICAgICAgLy8gRklYTUU6IHJlbW92ZSB0aGlzIGNhbGwg b25jZSB0aGUgY2hhbmdlcyB0byBDaHJvbWl1bSdzIHJlbmRlcndpZGdldCBoYXZlIGxhbmRlZC4K ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaCBiL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAppbmRleCBjMmVmMzEzMDdjMzliZWY3YjYwMmI4Mzgy MmJhODA3MTE4MGExZjBlLi5mMjUzMGFmODM1MTY1OTNkYjMxZWE0ZWY5ZTYzNGI5MTA5OWFlY2Q2 IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKKysrIGIvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBAIC00Niw2ICs0Niw3IEBACiAjaW5jbHVk ZSAiRWRpdG9yQ2xpZW50SW1wbC5oIgogI2luY2x1ZGUgIkdyYXBoaWNzTGF5ZXIuaCIKICNpbmNs dWRlICJJbnNwZWN0b3JDbGllbnRJbXBsLmgiCisjaW5jbHVkZSAiSW50UmVjdC5oIgogI2luY2x1 ZGUgIkxheWVyUmVuZGVyZXJDaHJvbWl1bS5oIgogI2luY2x1ZGUgIk5vdGlmaWNhdGlvblByZXNl bnRlckltcGwuaCIKICNpbmNsdWRlICJTcGVlY2hJbnB1dENsaWVudEltcGwuaCIKQEAgLTM5NSw2 ICszOTYsNyBAQCBwcml2YXRlOgogICAgIHZvaWQgc2V0SXNBY2NlbGVyYXRlZENvbXBvc2l0aW5n QWN0aXZlKGJvb2wpOwogICAgIHZvaWQgdXBkYXRlUm9vdExheWVyQ29udGVudHMoY29uc3QgV2Vi Q29yZTo6SW50UmVjdCYpOwogICAgIHZvaWQgZG9Db21wb3NpdGUoKTsKKyAgICB2b2lkIGRvUGl4 ZWxSZWFkYmFja1RvQ2FudmFzKFdlYkNhbnZhcyosIGNvbnN0IFdlYkNvcmU6OkludFJlY3QmKTsK ICNlbmRpZgogCiAgICAgV2ViVmlld0NsaWVudCogbV9jbGllbnQ7Cg== 67444 2010-09-13 11:46:41 -0700 2010-09-13 22:26:48 -0700 Patch bug-44127-20100913144740.patch text/plain 8514 wjmaclean ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MWIxNjQyNjg2MTI4NTBlOTE0YmEwYWNhYmQ1NWE0MzhhMGFhNjMwMS4uMzJmODg2YzI0MzgwN2Qz ZDBkMjhhYjdjZTZhNDI5NmVmZGMzYWJmMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMC0wOS0xMyAgVy4g SmFtZXMgTWFjTGVhbiAgPHdqbWFjbGVhbkBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVGh1bWJuYWlscyBub3Qg Z2VuZXJhdGVkIGZvciBHUFUgUmVuZGVyZWQgUGFnZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0MTI3CisKKyAgICAgICAgUmVwbGljYXRlcyBleGlz dGluZyBmdW5jdGlvbmFsaXR5LCB1c2UgZXhpc3RpbmcgdGVzdHMuCisgICAgICAgIEFkZHMgcGl4 ZWwtcmVhZGJhY2sgZm9yIEdQVSBjb21wb3NpdGVkIHBhZ2VzIHRvIGFsbG93IGZvciB0aHVtYm5h aWxpbmcsCisgICAgICAgIHByaW50aW5nIGFuZCBvdGhlciBzZXJ2aWNlcyB0byB3b3JrIHdpdGgg R1BVIHJlbmRlcmVkIHBhZ2VzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyUmVu ZGVyZXJDaHJvbWl1bTo6Z2V0RnJhbWVidWZmZXJQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2Vi Q29yZTo6TGF5ZXJSZW5kZXJlckNocm9taXVtOjpyb290TGF5ZXJUZXh0dXJlU2l6ZSk6CisKIDIw MTAtMDktMTMgIEpvbmF0aGFuIERpeG9uICA8am90aEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgU3RldmUgQmxvY2suCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAgYi9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5jcHAKaW5kZXggODk2 MDg0MTMwOTA0MjM5YTE4NmIyMDc5YjEwN2JkZjdkMzFjYTEzMC4uNTFjMGU0OTE4OWQ5NDdkOTIw ODliNWMyYWM2OTU3NTZiNzk4ZmUwNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uY3BwCisrKyBiL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmNwcApAQCAtMzU2 LDYgKzM1NiwyMCBAQCB2b2lkIExheWVyUmVuZGVyZXJDaHJvbWl1bTo6cHJlc2VudCgpCiAgICAg bV9uZWVkc0Rpc3BsYXkgPSBmYWxzZTsKIH0KIAordm9pZCBMYXllclJlbmRlcmVyQ2hyb21pdW06 OmdldEZyYW1lYnVmZmVyUGl4ZWxzKHZvaWQgKnBpeGVscywgY29uc3QgSW50UmVjdCYgcmVjdCkK K3sKKyAgICBBU1NFUlQocmVjdC5yaWdodCgpIDw9IHJvb3RMYXllclRleHR1cmVTaXplKCkud2lk dGgoKQorICAgICAgICAgICAmJiByZWN0LmJvdHRvbSgpIDw9IHJvb3RMYXllclRleHR1cmVTaXpl KCkuaGVpZ2h0KCkpOworCisgICAgaWYgKCFwaXhlbHMpCisgICAgICAgIHJldHVybjsKKworICAg IG1ha2VDb250ZXh0Q3VycmVudCgpOworCisgICAgR0xDKGdsUmVhZFBpeGVscyhyZWN0LngoKSwg cmVjdC55KCksIHJlY3Qud2lkdGgoKSwgcmVjdC5oZWlnaHQoKSwKKyAgICAgICAgICAgICAgICAg ICAgIEdMX1JHQkEsIEdMX1VOU0lHTkVEX0JZVEUsIHBpeGVscykpOworfQorCiAvLyBGSVhNRTog VGhpcyBtZXRob2Qgc2hvdWxkIGV2ZW50dWFsbHkgYmUgcmVwbGFjZWQgYnkgYSBwcm9wZXIgdGV4 dHVyZSBtYW5hZ2VyLgogdW5zaWduZWQgTGF5ZXJSZW5kZXJlckNocm9taXVtOjpjcmVhdGVMYXll clRleHR1cmUoKQogewpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllclJlbmRlcmVyQ2hyb21pdW0uaCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTGF5ZXJSZW5kZXJlckNocm9taXVtLmgKaW5kZXggMjc0ODE1ZjNmZTIzYzNiMDc4 YzQ3MDNlODQ1YjNiYmM4YzMzZWNiZC4uYjQ1NzRiMjgwYjBmMGNiOTE4ODVkNGRiOWRiNzQyNTIw YTAyNjA3MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXllclJlbmRlcmVyQ2hyb21pdW0uaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyUmVuZGVyZXJDaHJvbWl1bS5oCkBAIC05OCw2ICs5OCw5IEBAIHB1YmxpYzoK ICAgICBjb25zdCBDb250ZW50TGF5ZXJDaHJvbWl1bTo6U2hhcmVkVmFsdWVzKiBjb250ZW50TGF5 ZXJTaGFyZWRWYWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NvbnRlbnRMYXllclNoYXJlZFZhbHVl cy5nZXQoKTsgfQogICAgIGNvbnN0IENhbnZhc0xheWVyQ2hyb21pdW06OlNoYXJlZFZhbHVlcyog Y2FudmFzTGF5ZXJTaGFyZWRWYWx1ZXMoKSBjb25zdCB7IHJldHVybiBtX2NhbnZhc0xheWVyU2hh cmVkVmFsdWVzLmdldCgpOyB9CiAKKyAgICBJbnRTaXplIHJvb3RMYXllclRleHR1cmVTaXplKCkg Y29uc3QgeyByZXR1cm4gSW50U2l6ZShtX3Jvb3RMYXllclRleHR1cmVXaWR0aCwgbV9yb290TGF5 ZXJUZXh0dXJlSGVpZ2h0KTsgfQorICAgIHZvaWQgZ2V0RnJhbWVidWZmZXJQaXhlbHModm9pZCAq cGl4ZWxzLCBjb25zdCBJbnRSZWN0JiByZWN0KTsKKwogcHJpdmF0ZToKICAgICB2b2lkIHVwZGF0 ZUxheWVyc1JlY3Vyc2l2ZShMYXllckNocm9taXVtKiBsYXllciwgY29uc3QgVHJhbnNmb3JtYXRp b25NYXRyaXgmIHBhcmVudE1hdHJpeCwgZmxvYXQgb3BhY2l0eSk7CiAKZGlmZiAtLWdpdCBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDUzYzE2YzhmYWY2ODMyOTAwNzM2YmU4NzQyZDMzNWU1ZDk3ZTg4Y2MuLjNjZTNlMWQyMDZjOGVh ZWRjMWU1NTJjNzQ5ZTU4OGM2ODI3OWM1YWMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBA CisyMDEwLTA5LTEzICBXLiBKYW1lcyBNYWNMZWFuICA8d2ptYWNsZWFuQGdvb2dsZS5jb20+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVt XSBUaHVtYm5haWxzIG5vdCBnZW5lcmF0ZWQgZm9yIEdQVSBSZW5kZXJlZCBQYWdlcworICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQxMjcKKworICAgICAg ICBNb2RpZmllZCBXZWJWaWV3SW1wbDo6cGFpbnQoKSB0byBkZXRlY3Qgbm9uLW51bGwgY2FudmFz IHBvaW50ZXJzIHdoZW4KKyAgICAgICAgYWNjZWxlcmF0ZWQgY29tcG9zaXRpbmcgaXMgYWN0aXZl LCBhbmQgaW5zdGVhZCBmaWxscyB0aGUgcGl4ZWwgYnVmZmVyCisgICAgICAgIGZyb20gdGhlIEdQ VSBmcmFtZWJ1ZmZlci4gSW5jbHVkZXMgcmUtc2NhbGluZyBzdXBwb3J0IHdoZW4gcHJvdmlkZWQK KyAgICAgICAgY2FudmFzIGRvZXMgbm90IG1hdGNoIHNpemUgb2YgY3VycmVudCByZW5kZXIgbGF5 ZXIuIExpbWl0cyBwaXhlbAorICAgICAgICByZWFkYmFjayB0byByZWN0IHBhc3NlZCB0byBwYWlu dCgpLCBjbGlwcGVkIGJ5IHNpemUgb2Ygcm9vdExheWVyVGV4dHVyZS4KKworICAgICAgICAqIHNy Yy9XZWJWaWV3SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBsOjpkb1BpeGVs UmVhZGJhY2tUb0NhbnZhcyk6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBsOjpwYWludCk6 CisgICAgICAgICogc3JjL1dlYlZpZXdJbXBsLmg6CisKIDIwMTAtMDktMTMgIEpvbmF0aGFuIERp eG9uICA8am90aEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU3RldmUgQmxv Y2suCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcCBiL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4IDA0M2UzMjhhM2NiZTZlM2Y1 Yzc4NzM1MjI1ODgxMGFjYjU2MDljMTUuLjU2MjI4NDYyOTdjNTc0ZjI5ZTc1YmZhMTk0NmNiZDc0 YzIzNzYyNjMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3Bw CisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCkBAIC0zNCw2ICszNCw3 IEBACiAjaW5jbHVkZSAiQXV0b0ZpbGxQb3B1cE1lbnVDbGllbnQuaCIKICNpbmNsdWRlICJBWE9i amVjdENhY2hlLmgiCiAjaW5jbHVkZSAiQ2hyb21lLmgiCisjaW5jbHVkZSAiQ29sb3JTcGFjZS5o IgogI2luY2x1ZGUgIkNvbXBvc2l0aW9uVW5kZXJsaW5lVmVjdG9yQnVpbGRlci5oIgogI2luY2x1 ZGUgIkNvbnRleHRNZW51LmgiCiAjaW5jbHVkZSAiQ29udGV4dE1lbnVDb250cm9sbGVyLmgiCkBA IC02NCw4ICs2NSw5IEBACiAjaW5jbHVkZSAiSGl0VGVzdFJlc3VsdC5oIgogI2luY2x1ZGUgIkhU TUxOYW1lcy5oIgogI2luY2x1ZGUgIkltYWdlLmgiCisjaW5jbHVkZSAiSW1hZ2VCdWZmZXIuaCIK KyNpbmNsdWRlICJJbWFnZURhdGEuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JDb250cm9sbGVyLmgi Ci0jaW5jbHVkZSAiSW50UmVjdC5oIgogI2luY2x1ZGUgIktleWJvYXJkQ29kZXMuaCIKICNpbmNs dWRlICJLZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiTUlNRVR5cGVSZWdpc3RyeS5oIgpAQCAt MTE1LDcgKzExNywxMSBAQAogI2luY2x1ZGUgIldlYlN0cmluZy5oIgogI2luY2x1ZGUgIldlYlZl Y3Rvci5oIgogI2luY2x1ZGUgIldlYlZpZXdDbGllbnQuaCIKLSNpbmNsdWRlICJ3dGYvT3duUHRy LmgiCisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorCisjaWYgUExBVEZPUk0oQ0cpCisjaW5jbHVk ZSA8Q29yZUdyYXBoaWNzL0NHQ29udGV4dC5oPgorI2VuZGlmCiAKICNpZiBPUyhXSU5ET1dTKQog I2luY2x1ZGUgIlJlbmRlclRoZW1lQ2hyb21pdW1XaW4uaCIKQEAgLTk1MCwxNCArOTU2LDU3IEBA IHZvaWQgV2ViVmlld0ltcGw6OmxheW91dCgpCiAgICAgfQogfQogCisjaWYgVVNFKEFDQ0VMRVJB VEVEX0NPTVBPU0lUSU5HKQordm9pZCBXZWJWaWV3SW1wbDo6ZG9QaXhlbFJlYWRiYWNrVG9DYW52 YXMoV2ViQ2FudmFzKiBjYW52YXMsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgQVNTRVJU KHJlY3QucmlnaHQoKSA8PSBtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRleHR1cmVTaXplKCku d2lkdGgoKQorICAgICAgICAgICAmJiByZWN0LmJvdHRvbSgpIDw9IG1fbGF5ZXJSZW5kZXJlci0+ cm9vdExheWVyVGV4dHVyZVNpemUoKS5oZWlnaHQoKSk7CisKKyNpZiBQTEFURk9STShTS0lBKQor ICAgIFBsYXRmb3JtQ29udGV4dFNraWEgY29udGV4dChjYW52YXMpOworCisgICAgLy8gUGxhdGZv cm1HcmFwaGljc0NvbnRleHQgaXMgYWN0dWFsbHkgYSBwb2ludGVyIHRvIFBsYXRmb3JtQ29udGV4 dFNraWEKKyAgICBHcmFwaGljc0NvbnRleHQgZ2MocmVpbnRlcnByZXRfY2FzdDxQbGF0Zm9ybUdy YXBoaWNzQ29udGV4dCo+KCZjb250ZXh0KSk7CisgICAgaW50IGJpdG1hcEhlaWdodCA9IGNhbnZh cy0+Z2V0RGV2aWNlKCktPmFjY2Vzc0JpdG1hcChmYWxzZSkuaGVpZ2h0KCk7CisjZWxpZiBQTEFU Rk9STShDRykKKyAgICBHcmFwaGljc0NvbnRleHQgZ2MoY2FudmFzKTsKKyAgICBpbnQgYml0bWFw SGVpZ2h0ID0gQ0dCaXRtYXBDb250ZXh0R2V0SGVpZ2h0KHJlaW50ZXJwcmV0X2Nhc3Q8Q0dDb250 ZXh0UmVmPihjYW52YXMpKTsKKyNlbHNlCisgICAgbm90SW1wbGVtZW50ZWQoKTsKKyNlbmRpZgor ICAgIC8vIENvbXB1dGUgcmVjdCB0byBzYW1wbGUgZnJvbSBpbnZlcnRlZCBHUFUgYnVmZmVyLgor ICAgIEludFJlY3QgaW52ZXJ0UmVjdChyZWN0LngoKSwgYml0bWFwSGVpZ2h0IC0gcmVjdC5ib3R0 b20oKSwgcmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpKTsKKworICAgIE93blB0cjxJbWFnZUJ1 ZmZlcj4gaW1hZ2VCdWZmZXIoSW1hZ2VCdWZmZXI6OmNyZWF0ZShyZWN0LnNpemUoKSkpOworICAg IFJlZlB0cjxJbWFnZURhdGE+IGltYWdlRGF0YShJbWFnZURhdGE6OmNyZWF0ZShyZWN0LndpZHRo KCksIHJlY3QuaGVpZ2h0KCkpKTsKKyAgICBpZiAoaW1hZ2VCdWZmZXIuZ2V0KCkgJiYgaW1hZ2VE YXRhLmdldCgpKSB7CisgICAgICAgIG1fbGF5ZXJSZW5kZXJlci0+Z2V0RnJhbWVidWZmZXJQaXhl bHMoaW1hZ2VEYXRhLT5kYXRhKCktPmRhdGEoKS0+ZGF0YSgpLCBpbnZlcnRSZWN0KTsKKyAgICAg ICAgaW1hZ2VCdWZmZXItPnB1dFByZW11bHRpcGxpZWRJbWFnZURhdGEoaW1hZ2VEYXRhLmdldCgp LCBJbnRSZWN0KEludFBvaW50KCksIHJlY3Quc2l6ZSgpKSwgSW50UG9pbnQoKSk7CisgICAgICAg IGdjLnNhdmUoKTsKKyAgICAgICAgZ2MudHJhbnNsYXRlKEZsb2F0U2l6ZSgwLjBmLCBiaXRtYXBI ZWlnaHQpKTsKKyAgICAgICAgZ2Muc2NhbGUoRmxvYXRTaXplKDEuMGYsIC0xLjBmKSk7CisgICAg ICAgIC8vIFVzZSBpbnZlcnRSZWN0IGluIG5leHQgbGluZSwgc28gdGhhdCB0cmFuc2Zvcm0gYWJv dmUgaW52ZXJ0cyBpdCBiYWNrIHRvCisgICAgICAgIC8vIGRlc2lyZWQgZGVzdGluYXRpb24gcmVj dC4KKyAgICAgICAgZ2MuZHJhd0ltYWdlQnVmZmVyKGltYWdlQnVmZmVyLmdldCgpLCBEZXZpY2VD b2xvclNwYWNlLCBpbnZlcnRSZWN0LmxvY2F0aW9uKCkpOworICAgICAgICBnYy5yZXN0b3JlKCk7 CisgICAgfQorfQorI2VuZGlmCisKIHZvaWQgV2ViVmlld0ltcGw6OnBhaW50KFdlYkNhbnZhcyog Y2FudmFzLCBjb25zdCBXZWJSZWN0JiByZWN0KQogewogICAgIGlmIChpc0FjY2VsZXJhdGVkQ29t cG9zaXRpbmdBY3RpdmUoKSkgewogI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKICAg ICAgICAgZG9Db21wb3NpdGUoKTsKIAotICAgICAgICAvLyBSZWFkYmFjayBpbnRvIHRoZSBjYW52 YXMKLSAgICAgICAgLy8gRklYTUUgSW5zZXJ0IHdqbWFjbGVhbidzIHJlYWRiYWNrIGNvZGUgaGVy ZSBmb3Igd2Via2l0IGJ1ZyA0NDEyNworICAgICAgICAvLyBJZiBhIGNhbnZhcyB3YXMgcGFzc2Vk IGluLCB3ZSB1c2UgaXQgdG8gZ3JhYiBhIGNvcHkgb2YgdGhlCisgICAgICAgIC8vIGZyZXNobHkt cmVuZGVyZWQgcGl4ZWxzLgorICAgICAgICBpZiAoY2FudmFzKSB7CisgICAgICAgICAgICAvLyBD bGlwIHJlY3QgdG8gdGhlIGNvbmZpbmVzIG9mIHRoZSByb290TGF5ZXJUZXh0dXJlLgorICAgICAg ICAgICAgSW50UmVjdCByZXNpemVSZWN0KHJlY3QpOworICAgICAgICAgICAgcmVzaXplUmVjdC5p bnRlcnNlY3QoSW50UmVjdChJbnRQb2ludCgpLCBtX2xheWVyUmVuZGVyZXItPnJvb3RMYXllclRl eHR1cmVTaXplKCkpKTsKKyAgICAgICAgICAgIGRvUGl4ZWxSZWFkYmFja1RvQ2FudmFzKGNhbnZh cywgcmVzaXplUmVjdCk7CisgICAgICAgIH0KIAogICAgICAgICAvLyBUZW1wb3JhcmlseSBwcmVz ZW50IHNvIHRoZSBkb3duc3RyZWFtIENocm9taXVtIHJlbmRlcndpZGdldCBzdGlsbCByZW5kZXJz LgogICAgICAgICAvLyBGSVhNRTogcmVtb3ZlIHRoaXMgY2FsbCBvbmNlIHRoZSBjaGFuZ2VzIHRv IENocm9taXVtJ3MgcmVuZGVyd2lkZ2V0IGhhdmUgbGFuZGVkLgpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3 SW1wbC5oCmluZGV4IGMyZWYzMTMwN2MzOWJlZjdiNjAyYjgzODIyYmE4MDcxMTgwYTFmMGUuLmYy NTMwYWY4MzUxNjU5M2RiMzFlYTRlZjllNjM0YjkxMDk5YWVjZDYgMTAwNjQ0Ci0tLSBhL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YlZpZXdJbXBsLmgKQEAgLTQ2LDYgKzQ2LDcgQEAKICNpbmNsdWRlICJFZGl0b3JDbGllbnRJbXBs LmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NMYXllci5oIgogI2luY2x1ZGUgIkluc3BlY3RvckNsaWVu dEltcGwuaCIKKyNpbmNsdWRlICJJbnRSZWN0LmgiCiAjaW5jbHVkZSAiTGF5ZXJSZW5kZXJlckNo cm9taXVtLmgiCiAjaW5jbHVkZSAiTm90aWZpY2F0aW9uUHJlc2VudGVySW1wbC5oIgogI2luY2x1 ZGUgIlNwZWVjaElucHV0Q2xpZW50SW1wbC5oIgpAQCAtMzk1LDYgKzM5Niw3IEBAIHByaXZhdGU6 CiAgICAgdm9pZCBzZXRJc0FjY2VsZXJhdGVkQ29tcG9zaXRpbmdBY3RpdmUoYm9vbCk7CiAgICAg dm9pZCB1cGRhdGVSb290TGF5ZXJDb250ZW50cyhjb25zdCBXZWJDb3JlOjpJbnRSZWN0Jik7CiAg ICAgdm9pZCBkb0NvbXBvc2l0ZSgpOworICAgIHZvaWQgZG9QaXhlbFJlYWRiYWNrVG9DYW52YXMo V2ViQ2FudmFzKiwgY29uc3QgV2ViQ29yZTo6SW50UmVjdCYpOwogI2VuZGlmCiAKICAgICBXZWJW aWV3Q2xpZW50KiBtX2NsaWVudDsK