73186 2011-11-27 22:29:36 -0800 [Chromium]Draw small cached canvases to an onscreen large canvas is slow when 2D canvas is HW accelerated. 2012-02-17 00:58:12 -0800 1 1 1 Unclassified WebKit Canvas 528+ (Nightly build) PC Linux RESOLVED FIXED P2 Normal --- 0 jin.a.yang jin.a.yang bsalomon cc-bugs fishd jamesr junov mdelaney7 reed senorblanco tommyw webkit.review.bot oldest_to_newest 509569 0 jin.a.yang 2011-11-27 22:29:36 -0800 Run GUIMark3 "Bitmap Test" benchmark in chromium on Linux. http://www.craftymind.com/guimark3/ This benchmark has two scenario, normal mode:GM3_JS_Bitmap.html and cached mode:GM3_JS_Bitmap_cache.html The normal mode show 60FPS and cached mode show about 12 FPS on my platform when enable accelerated-2d-canvas. The normal mode: draw several small images(less than 128*128) into onscreen canvas(480*640) by call context.drawImage() when running. The cached mode: when initialize, create a canvas for each image and draw image into this canvas. When running, just draw these cached canvases into the onscreen canvas. The root cause is: in cached mode, when draw the cached canvas to onscreen canvas, it will load the cached canvas(ImageBuffer) into texture, but the generation id bounded with this ImageBuffer's bitmap is not saved because every time in ImageBuffer::draw(), we create a new Image based on the bitmap. So it will not be found in the cached texture next time and will be loaded to gpu texture every time which show poor performance. The fix is to hold an Image member for ImageBuffer, then no need to create an Image every time before draw, just like other port like ImageBufferQt.cpp does. After the fix, the cached mode show 60FPS in my platform, same to normal mode. 509573 1 116699 jin.a.yang 2011-11-27 22:43:04 -0800 Created attachment 116699 patch for this bug 516443 2 jin.a.yang 2011-12-06 19:23:15 -0800 any comments for this issue? 517053 3 jamesr 2011-12-07 18:03:35 -0800 I'm not sure I fully understand the consequences of this patch. Perhaps Stephen or Mike could take a look. 517765 4 116699 senorblanco 2011-12-08 13:59:14 -0800 Comment on attachment 116699 patch for this bug View in context: https://bugs.webkit.org/attachment.cgi?id=116699&action=review > Source/WebCore/platform/graphics/skia/ImageBufferSkia.cpp:122 > + m_data.m_image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), false); Thank you for the patch. I'm wondering how this change will behave in the non-static case: if you subsequently change the source canvas and re-draw it to the destination, since this bitmap has already been copied will it be successfully generation-bumped and the texture re-uploaded? Have you tested this case? > Source/WebCore/platform/graphics/skia/ImageBufferSkia.cpp:164 > + if (context == m_context) { I've been changing this code a bit recently. You'll have to sync up to tip-of-tree, since this condition has changed. 518259 5 jin.a.yang 2011-12-09 07:32:29 -0800 Thanks for your remainder, I just tested the non-static case you mentioned: I randomly draw rect with different color(fillRect) into the cached canvas, the texture was not re-uploaded. After debug, I found the root cause is as follow: 1. in fillRect to the cached canvas, it use canvas->fDevice->bitmap to finish the operation. As pixels changed, the bitmap's generation id will set to 0; 2. when draw this cached canvas to accelerated big canvas, it will use m_data.m_image->bitmap(as my fix) to finish the operation. the bitmap's generation id is not 0, so we will use this id to find the cached texture, the texture is not re-loaded. I tried the below code, that is to check bitmap's content is changed before we draw. It works and the texture will be re-uploaded after the source canvas content changed: // if the bitmap's content has changed, we have to update m_image. if( m_data.m_platformContext.bitmap()->getGenerationID() != m_data.m_image.get()->nativeImageForCurrentFrame()->bitmap().getGenerationID()) { m_data.m_image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), false); } if (drawNeedsCopy(m_context.get(), context)) { // We are drawing to our own buffer, copy the source buffer first RefPtr<Image> copy = copyImage(CopyBackingStore); context->drawImage(copy.get(), styleColorSpace, destRect, srcRect, op, useLowQualityScale); } else context->drawImage(m_data.m_image.get(), styleColorSpace, destRect, srcRect, op, useLowQualityScale); Any suggestion to it? Thanks (In reply to comment #4) > (From update of attachment 116699 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=116699&action=review > > > Source/WebCore/platform/graphics/skia/ImageBufferSkia.cpp:122 > > + m_data.m_image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), false); > > Thank you for the patch. > > I'm wondering how this change will behave in the non-static case: if you subsequently change the source canvas and re-draw it to the destination, since this bitmap has already been copied will it be successfully generation-bumped and the texture re-uploaded? Have you tested this case? > > > Source/WebCore/platform/graphics/skia/ImageBufferSkia.cpp:164 > > + if (context == m_context) { > > I've been changing this code a bit recently. You'll have to sync up to tip-of-tree, since this condition has changed. 518266 6 senorblanco 2011-12-09 07:54:25 -0800 (In reply to comment #5) > Thanks for your remainder, I just tested the non-static case you mentioned: I randomly draw rect with different color(fillRect) into the cached canvas, the texture was not re-uploaded. > After debug, I found the root cause is as follow: > 1. in fillRect to the cached canvas, it use canvas->fDevice->bitmap to finish the operation. As pixels changed, the bitmap's generation id will set to 0; > 2. when draw this cached canvas to accelerated big canvas, it will use m_data.m_image->bitmap(as my fix) to finish the operation. the bitmap's generation id is not 0, so we will use this id to find the cached texture, the texture is not re-loaded. > > I tried the below code, that is to check bitmap's content is changed before we draw. It works and the texture will be re-uploaded after the source canvas content changed: > // if the bitmap's content has changed, we have to update m_image. > if( m_data.m_platformContext.bitmap()->getGenerationID() != m_data.m_image.get()->nativeImageForCurrentFrame()->bitmap().getGenerationID()) I don't think explicitly checking the generation ID is that right way to go; this should be handled internally (although perhaps Brian can comment on that). I'm wondering if the root cause of this issue might be related to https://bugs.webkit.org/show_bug.cgi?id=74183. If that issue were fixed, perhaps we could come up with a cleaner fix to this issue as well. { > m_data.m_image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), false); > } > > if (drawNeedsCopy(m_context.get(), context)) { > // We are drawing to our own buffer, copy the source buffer first > RefPtr<Image> copy = copyImage(CopyBackingStore); > context->drawImage(copy.get(), styleColorSpace, destRect, srcRect, op, useLowQualityScale); > } else > context->drawImage(m_data.m_image.get(), styleColorSpace, destRect, srcRect, op, useLowQualityScale); > > Any suggestion to it? Thanks > > (In reply to comment #4) > > (From update of attachment 116699 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=116699&action=review > > > > > Source/WebCore/platform/graphics/skia/ImageBufferSkia.cpp:122 > > > + m_data.m_image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), false); > > > > Thank you for the patch. > > > > I'm wondering how this change will behave in the non-static case: if you subsequently change the source canvas and re-draw it to the destination, since this bitmap has already been copied will it be successfully generation-bumped and the texture re-uploaded? Have you tested this case? > > > > > Source/WebCore/platform/graphics/skia/ImageBufferSkia.cpp:164 > > > + if (context == m_context) { > > > > I've been changing this code a bit recently. You'll have to sync up to tip-of-tree, since this condition has changed. 518269 7 junov 2011-12-09 08:03:54 -0800 It is possible that a preferable fix for this issue would be to make sure that the generation ID is managed correctly. This bug might be related: https://bugs.webkit.org/show_bug.cgi?id=74183 518281 8 bsalomon 2011-12-09 08:32:18 -0800 (In reply to comment #7) > It is possible that a preferable fix for this issue would be to make sure that the generation ID is managed correctly. > > This bug might be related: https://bugs.webkit.org/show_bug.cgi?id=74183 I agree. Let's not have WK directly inspecting the gen ID. It does seem likely to be the same or related to 74183. 518961 9 jin.a.yang 2011-12-11 18:31:22 -0800 Thanks for the comments! Yes, I just used it to verify the root cause. I also prefer to fix it in manage the generation id correctly. I will check whether we need to do a clean fix after bug 74183 554046 10 126509 tommyw 2012-02-10 06:15:21 -0800 Created attachment 126509 Patch 554047 11 webkit.review.bot 2012-02-10 06:17:09 -0800 Please wait for approval from fishd@chromium.org before submitting because this patch contains changes to the Chromium public API. 554053 12 tommyw 2012-02-10 06:22:25 -0800 Yikes! Uploaded my patch to the wrong bug... So sorry! 554056 13 bsalomon 2012-02-10 06:35:09 -0800 Can this bug be closed? 559018 14 jin.a.yang 2012-02-17 00:58:12 -0800 It has been fixed in https://bugs.webkit.org/show_bug.cgi?id=68420 116699 2011-11-27 22:43:04 -0800 2012-02-10 06:25:49 -0800 patch for this bug patch text/plain 4339 jin.a.yang SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDEwMTA0NCkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIwIEBACisyMDExLTExLTI3ICBKaW4gWWFu ZyAgPGppbi5hLnlhbmdAaW50ZWwuY29tPgorCisgICAgICAgIFtDaHJvbWl1bV1EcmF3IHNtYWxs IGNhY2hlZCBjYW52YXNlcyB0byBhbiBvbnNjcmVlbiBsYXJnZSBjYW52YXMgaXMgc2xvdyB3aGVu IDJEIGNhbnZhcyBpcyBIVyBhY2NlbGVyYXRlZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTczMTg2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQWRkIGFuIG1lbWViZXIgdG8gaG9sZCB0aGUgSW1hZ2UgZm9y IEltYWdlQnVmZmVyLCB0aGVuIHdlIGRvIG5vdCBuZWVkIHRvIGNyZWF0ZSBhbiBJbWFnZSBiZWZv cmUgZHJhdy4KKyAgICAgICAgQWZ0ZXIgZ2VuZXJhdGluZyBHUFUgdGV4dHVyZSBmb3IgdGhlIElt YWdlJ3MgYml0bWFwIGJ5IHVzaW5nIGJpdG1hcCdzIGdlbmVyYXRpb24gaWQsIHdlIGNhbiB1c2lu ZyB0aGlzCisgICAgICAgIGlkIHRvIGxvb2t1cCB0aGUgdGV4dHVyZSBpbiB0aGUgY2FjaGVkIHRh YmxlLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VCdWZmZXJE YXRhU2tpYS5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL3NraWEvSW1hZ2VCdWZmZXJT a2lhLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkltYWdlQnVmZmVyOjpJbWFnZUJ1ZmZlcik6Cisg ICAgICAgIChXZWJDb3JlOjpJbWFnZUJ1ZmZlcjo6ZHJhdyk6CisgICAgICAgIChXZWJDb3JlOjpJ bWFnZUJ1ZmZlcjo6ZHJhd1BhdHRlcm4pOgorCiAyMDExLTExLTIyICBLZW5uZXRoIFJ1c3NlbGwg IDxrYnJAZ29vZ2xlLmNvbT4KIAogICAgICAgICBbY2hyb21pdW1dIFN1cHBvcnQgQ29yZSBBbmlt YXRpb24gcGx1Z2lucyBpbiBjb21wb3NpdG9yCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9JbWFnZUJ1ZmZlckRhdGFTa2lhLmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VCdWZmZXJEYXRh U2tpYS5oCShyZXZpc2lvbiAxMDEwNDQpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9JbWFnZUJ1ZmZlckRhdGFTa2lhLmgJKHdvcmtpbmcgY29weSkKQEAgLTQz LDYgKzQzLDcgQEAgcHVibGljOgogICAgIEltYWdlQnVmZmVyRGF0YShjb25zdCBJbnRTaXplJik7 CiAKICAgICBPd25QdHI8U2tDYW52YXM+IG1fY2FudmFzOworICAgIFJlZlB0cjxJbWFnZT4gbV9p bWFnZTsKICAgICBQbGF0Zm9ybUNvbnRleHRTa2lhIG1fcGxhdGZvcm1Db250ZXh0OwogI2lmIFVT RShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKICAgICBSZWZQdHI8Q2FudmFzMkRMYXllckNocm9t aXVtPiBtX3BsYXRmb3JtTGF5ZXI7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9za2lhL0ltYWdlQnVmZmVyU2tpYS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3Mvc2tpYS9JbWFnZUJ1ZmZlclNraWEuY3BwCShyZXZpc2lvbiAx MDEwNDQpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9za2lhL0ltYWdlQnVm ZmVyU2tpYS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTExOCw3ICsxMTgsOCBAQCBJbWFnZUJ1ZmZl cjo6SW1hZ2VCdWZmZXIoY29uc3QgSW50U2l6ZSYKICAgICAvLyBNYWtlIHRoZSBiYWNrZ3JvdW5k IHRyYW5zcGFyZW50LiBJdCB3b3VsZCBiZSBuaWNlIGlmIHRoaXMgd2Fzbid0CiAgICAgLy8gcmVx dWlyZWQsIGJ1dCB0aGUgY2FudmFzIGlzIGN1cnJlbnRseSBmaWxsZWQgd2l0aCB0aGUgbWFnaWMg dHJhbnNwYXJlbmN5CiAgICAgLy8gY29sb3IuIENhbiB3ZSBoYXZlIGFub3RoZXIgd2F5IHRvIG1h bmFnZSB0aGlzPwotICAgIG1fZGF0YS5tX2NhbnZhcy0+ZHJhd0FSR0IoMCwgMCwgMCwgMCwgU2tY ZmVybW9kZTo6a0NsZWFyX01vZGUpOworICAgIG1fZGF0YS5tX2NhbnZhcy0+ZHJhd0FSR0IoMCwg MCwgMCwgMCwgU2tYZmVybW9kZTo6a0NsZWFyX01vZGUpOyAKKyAgICBtX2RhdGEubV9pbWFnZSA9 IEJpdG1hcEltYWdlU2luZ2xlRnJhbWVTa2lhOjpjcmVhdGUoKm1fZGF0YS5tX3BsYXRmb3JtQ29u dGV4dC5iaXRtYXAoKSwgZmFsc2UpOwogCiAgICAgc3VjY2VzcyA9IHRydWU7CiB9CkBAIC0xNjAs MTUgKzE2MSwyMyBAQCB2b2lkIEltYWdlQnVmZmVyOjpjbGlwKEdyYXBoaWNzQ29udGV4dCoKIHZv aWQgSW1hZ2VCdWZmZXI6OmRyYXcoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBDb2xvclNwYWNl IHN0eWxlQ29sb3JTcGFjZSwgY29uc3QgRmxvYXRSZWN0JiBkZXN0UmVjdCwgY29uc3QgRmxvYXRS ZWN0JiBzcmNSZWN0LAogICAgICAgICAgICAgICAgICAgICAgICBDb21wb3NpdGVPcGVyYXRvciBv cCwgYm9vbCB1c2VMb3dRdWFsaXR5U2NhbGUpCiB7Ci0gICAgUmVmUHRyPEltYWdlPiBpbWFnZSA9 IEJpdG1hcEltYWdlU2luZ2xlRnJhbWVTa2lhOjpjcmVhdGUoKm1fZGF0YS5tX3BsYXRmb3JtQ29u dGV4dC5iaXRtYXAoKSwgY29udGV4dCA9PSBtX2NvbnRleHQpOwotICAgIGNvbnRleHQtPmRyYXdJ bWFnZShpbWFnZS5nZXQoKSwgc3R5bGVDb2xvclNwYWNlLCBkZXN0UmVjdCwgc3JjUmVjdCwgb3As IHVzZUxvd1F1YWxpdHlTY2FsZSk7CisgICAgaWYgKGNvbnRleHQgPT0gbV9jb250ZXh0KSB7Cisg ICAgICAgIC8vIFdlIGFyZSBkcmF3aW5nIHRvIG91ciBvd24gYnVmZmVyLCBjb3B5IHRoZSBzb3Vy Y2UgYnVmZmVyIGZpcnN0CisgICAgICAgIFJlZlB0cjxJbWFnZT4gY29weSA9IGNvcHlJbWFnZShD b3B5QmFja2luZ1N0b3JlKTsKKyAgICAgICAgY29udGV4dC0+ZHJhd0ltYWdlKGNvcHkuZ2V0KCks IHN0eWxlQ29sb3JTcGFjZSwgZGVzdFJlY3QsIHNyY1JlY3QsIG9wLCB1c2VMb3dRdWFsaXR5U2Nh bGUpOworICAgIH0gZWxzZQorICAgICAgICBjb250ZXh0LT5kcmF3SW1hZ2UobV9kYXRhLm1faW1h Z2UuZ2V0KCksIHN0eWxlQ29sb3JTcGFjZSwgZGVzdFJlY3QsIHNyY1JlY3QsIG9wLCB1c2VMb3dR dWFsaXR5U2NhbGUpOwogfQogCiB2b2lkIEltYWdlQnVmZmVyOjpkcmF3UGF0dGVybihHcmFwaGlj c0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEZsb2F0UmVjdCYgc3JjUmVjdCwgY29uc3QgQWZmaW5l VHJhbnNmb3JtJiBwYXR0ZXJuVHJhbnNmb3JtLAogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgY29uc3QgRmxvYXRQb2ludCYgcGhhc2UsIENvbG9yU3BhY2Ugc3R5bGVDb2xvclNwYWNlLCBD b21wb3NpdGVPcGVyYXRvciBvcCwgY29uc3QgRmxvYXRSZWN0JiBkZXN0UmVjdCkKIHsKLSAgICBS ZWZQdHI8SW1hZ2U+IGltYWdlID0gQml0bWFwSW1hZ2VTaW5nbGVGcmFtZVNraWE6OmNyZWF0ZSgq bV9kYXRhLm1fcGxhdGZvcm1Db250ZXh0LmJpdG1hcCgpLCBjb250ZXh0ID09IG1fY29udGV4dCk7 Ci0gICAgaW1hZ2UtPmRyYXdQYXR0ZXJuKGNvbnRleHQsIHNyY1JlY3QsIHBhdHRlcm5UcmFuc2Zv cm0sIHBoYXNlLCBzdHlsZUNvbG9yU3BhY2UsIG9wLCBkZXN0UmVjdCk7CisgICAgaWYgKGNvbnRl eHQgPT0gbV9jb250ZXh0KSB7CisgICAgICAgIC8vIFdlIGFyZSBkcmF3aW5nIHRvIG91ciBvd24g YnVmZmVyLCBjb3B5IHRoZSBzb3VyY2UgYnVmZmVyIGZpcnN0CisgICAgICAgIFJlZlB0cjxJbWFn ZT4gY29weSA9IGNvcHlJbWFnZShDb3B5QmFja2luZ1N0b3JlKTsKKyAgICAgICAgY29weS0+ZHJh d1BhdHRlcm4oY29udGV4dCwgc3JjUmVjdCwgcGF0dGVyblRyYW5zZm9ybSwgcGhhc2UsIHN0eWxl Q29sb3JTcGFjZSwgb3AsIGRlc3RSZWN0KTsKKyAgICB9IGVsc2UKKyAgICAgICAgbV9kYXRhLm1f aW1hZ2UtPmRyYXdQYXR0ZXJuKGNvbnRleHQsIHNyY1JlY3QsIHBhdHRlcm5UcmFuc2Zvcm0sIHBo YXNlLCBzdHlsZUNvbG9yU3BhY2UsIG9wLCBkZXN0UmVjdCk7CiB9CiAKIHZvaWQgSW1hZ2VCdWZm ZXI6OnBsYXRmb3JtVHJhbnNmb3JtQ29sb3JTcGFjZShjb25zdCBWZWN0b3I8aW50PiYgbG9va1Vw VGFibGUpCg== 126509 2012-02-10 06:15:21 -0800 2012-02-10 06:25:27 -0800 Patch bug-73186-20120210151519.patch text/plain 11107 tommyw U3VidmVyc2lvbiBSZXZpc2lvbjogMTA3Mzg3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMmFhYTc0NjUyNmI0M2Y5 NWQ3YmMxMWE0ZWM2MGM0NmM3ODc2OTE5Ny4uMjA2ODgxMTk5N2RkMTBmZWFlNGY0YmRiMzEyM2Jk ZGI0OGU4ZWFjZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEyLTAyLTEwICBUb21t eSBXaWRlbmZseWNodCAgPHRvbW15d0Bnb29nbGUuY29tPgorCisgICAgICAgIE1lZGlhU3RyZWFt IEFQSTogUmVtb3ZpbmcgU2VjdXJpdHlDb250ZXh0IGZyb20gdGhlIGVtYmVkZGVyIEFQSQorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzM4MTYKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0cyBmb3IgdGhl IE1lZGlhIFN0cmVhbSBBUEkgd2lsbCBiZSBwcm92aWRlZCBieSB0aGUgYnVnIDU2NTg3LCBwZW5k aW5nIGVub3VnaCBsYW5kZWQgY29kZS4KKworICAgICAgICAqIG1lZGlhc3RyZWFtL1BlZXJDb25u ZWN0aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBlZXJDb25uZWN0aW9uOjpQZWVyQ29ubmVj dGlvbik6CisgICAgICAgICogcGxhdGZvcm0vbWVkaWFzdHJlYW0vUGVlckNvbm5lY3Rpb25IYW5k bGVyLmg6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFBlZXJDb25uZWN0aW9uSGFuZGxl cik6CisgICAgICAgICogcGxhdGZvcm0vbWVkaWFzdHJlYW0vZ3N0cmVhbWVyL1BlZXJDb25uZWN0 aW9uSGFuZGxlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQZWVyQ29ubmVjdGlvbkhhbmRsZXI6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQZWVyQ29ubmVjdGlvbkhhbmRsZXI6OlBlZXJD b25uZWN0aW9uSGFuZGxlcik6CisKIDIwMTItMDItMTAgIFZzZXZvbG9kIFZsYXNvdiAgPHZzZXZp a0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogRmlsZVNlbGVjdG9yIHNo b3VsZCBub3QgZGVwZW5kIG9uIERlYnVnZ2VyUHJlc2VudGF0aW9uTW9kZWwuCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nCmluZGV4IDQ3OTM1YTBmYTA0MWNkZGM3NjRkMTJmYmFiN2UwNmEzMDg4NWNj MGUuLjI4NjRkMjljODYxZWViMGVjOTU5OTEyNmFlMDI0MjZhODgxZmRlYTAgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTItMDItMTAgIFRvbW15IFdpZGVu Zmx5Y2h0ICA8dG9tbXl3QGdvb2dsZS5jb20+CisKKyAgICAgICAgTWVkaWFTdHJlYW0gQVBJOiBS ZW1vdmluZyBTZWN1cml0eUNvbnRleHQgZnJvbSB0aGUgZW1iZWRkZXIgQVBJCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MzgxNgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogYnJpZGdlL1BlZXJDb25uZWN0 aW9uSGFuZGxlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQZWVyQ29ubmVjdGlvbkhhbmRsZXI6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQZWVyQ29ubmVjdGlvbkhhbmRsZXI6OlBlZXJD b25uZWN0aW9uSGFuZGxlcik6CisgICAgICAgICogYnJpZGdlL1BlZXJDb25uZWN0aW9uSGFuZGxl ckludGVybmFsLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBlZXJDb25uZWN0aW9uSGFuZGxlcklu dGVybmFsOjpQZWVyQ29ubmVjdGlvbkhhbmRsZXJJbnRlcm5hbCk6CisgICAgICAgICogYnJpZGdl L1BlZXJDb25uZWN0aW9uSGFuZGxlckludGVybmFsLmg6CisgICAgICAgIChXZWJDb3JlKToKKyAg ICAgICAgKFBlZXJDb25uZWN0aW9uSGFuZGxlckludGVybmFsKToKKyAgICAgICAgKiBwdWJsaWMv cGxhdGZvcm0vV2ViUGVlckNvbm5lY3Rpb25IYW5kbGVyLmg6CisgICAgICAgIChXZWJQZWVyQ29u bmVjdGlvbkhhbmRsZXIpOgorICAgICAgICAoV2ViS2l0OjpXZWJQZWVyQ29ubmVjdGlvbkhhbmRs ZXI6OmluaXRpYWxpemUpOgorCiAyMDEyLTAyLTA5ICBLZW5pY2hpIElzaGliYXNoaSAgPGJhc2hp QGNocm9taXVtLm9yZz4KIAogICAgICAgICBBZGQgV2ViU29ja2V0IGV4dGVuc2lvbiBzdXBwb3J0 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbi5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbi5jcHAKaW5kZXgg MGI4YjA0OTY4MTg1NDEwMTA5YjM3MzFhMjU4MmY2NzNmZDdkZGVkYS4uNGRkM2JmMGRhMjVjY2I0 MzE3NDNlZjc4Zjg4MGVlMTc5N2ZlYWRkMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbWVk aWFzdHJlYW0vUGVlckNvbm5lY3Rpb24uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3Ry ZWFtL1BlZXJDb25uZWN0aW9uLmNwcApAQCAtNTYsNyArNTYsNyBAQCBQZWVyQ29ubmVjdGlvbjo6 UGVlckNvbm5lY3Rpb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3QgU3Ry aW5nJiBzZQogICAgICwgbV9pbml0aWFsTmVnb3RpYXRpb25UaW1lcih0aGlzLCAmUGVlckNvbm5l Y3Rpb246OmluaXRpYWxOZWdvdGlhdGlvblRpbWVyRmlyZWQpCiAgICAgLCBtX3N0cmVhbUNoYW5n ZVRpbWVyKHRoaXMsICZQZWVyQ29ubmVjdGlvbjo6c3RyZWFtQ2hhbmdlVGltZXJGaXJlZCkKICAg ICAsIG1fcmVhZHlTdGF0ZUNoYW5nZVRpbWVyKHRoaXMsICZQZWVyQ29ubmVjdGlvbjo6cmVhZHlT dGF0ZUNoYW5nZVRpbWVyRmlyZWQpCi0gICAgLCBtX3BlZXJIYW5kbGVyKFBlZXJDb25uZWN0aW9u SGFuZGxlcjo6Y3JlYXRlKHRoaXMsIHNlcnZlckNvbmZpZ3VyYXRpb24sIGNvbnRleHQtPnNlY3Vy aXR5T3JpZ2luKCkpKQorICAgICwgbV9wZWVySGFuZGxlcihQZWVyQ29ubmVjdGlvbkhhbmRsZXI6 OmNyZWF0ZSh0aGlzLCBzZXJ2ZXJDb25maWd1cmF0aW9uLCBjb250ZXh0LT5zZWN1cml0eU9yaWdp bigpLT50b1N0cmluZygpKSkKIHsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vbWVkaWFzdHJlYW0vUGVlckNvbm5lY3Rpb25IYW5kbGVyLmggYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbkhhbmRsZXIuaAppbmRleCA3Nzhj ZDFiMjUwZTdjMmExNGYwODZlYjk5YjM5MWNlZmU4NjhiZjNiLi5mYTIyY2Y0YzdjYTQyODA1NTI5 OTNlNDIzZWFiZWNkODczZGYxYWM1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9tZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbkhhbmRsZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbkhhbmRsZXIuaApAQCAtNDEsNyAr NDEsNiBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBQZWVyQ29ubmVjdGlvbkhhbmRs ZXJDbGllbnQ7Ci1jbGFzcyBTZWN1cml0eU9yaWdpbjsKIAogI2lmIFBMQVRGT1JNKENIUk9NSVVN KQogY2xhc3MgUGVlckNvbm5lY3Rpb25IYW5kbGVySW50ZXJuYWw7CkBAIC01MSw3ICs1MCw3IEBA IGNsYXNzIFBlZXJDb25uZWN0aW9uSGFuZGxlciB7CiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUo UGVlckNvbm5lY3Rpb25IYW5kbGVyKTsKICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKIHB1 YmxpYzoKLSAgICBzdGF0aWMgUGFzc093blB0cjxQZWVyQ29ubmVjdGlvbkhhbmRsZXI+IGNyZWF0 ZShQZWVyQ29ubmVjdGlvbkhhbmRsZXJDbGllbnQqLCBjb25zdCBTdHJpbmcmIHNlcnZlckNvbmZp Z3VyYXRpb24sIFBhc3NSZWZQdHI8U2VjdXJpdHlPcmlnaW4+KTsKKyAgICBzdGF0aWMgUGFzc093 blB0cjxQZWVyQ29ubmVjdGlvbkhhbmRsZXI+IGNyZWF0ZShQZWVyQ29ubmVjdGlvbkhhbmRsZXJD bGllbnQqLCBjb25zdCBTdHJpbmcmIHNlcnZlckNvbmZpZ3VyYXRpb24sIGNvbnN0IFN0cmluZyYg dXNlcm5hbWUpOwogICAgIH5QZWVyQ29ubmVjdGlvbkhhbmRsZXIoKTsKIAogICAgIHZvaWQgcHJv ZHVjZUluaXRpYWxPZmZlcihjb25zdCBNZWRpYVN0cmVhbURlc2NyaXB0b3JWZWN0b3ImIHBlbmRp bmdBZGRTdHJlYW1zKTsKQEAgLTYzLDcgKzYyLDcgQEAgcHVibGljOgogICAgIHZvaWQgc3RvcCgp OwogCiBwcml2YXRlOgotICAgIFBlZXJDb25uZWN0aW9uSGFuZGxlcihQZWVyQ29ubmVjdGlvbkhh bmRsZXJDbGllbnQqLCBjb25zdCBTdHJpbmcmIHNlcnZlckNvbmZpZ3VyYXRpb24sIFBhc3NSZWZQ dHI8U2VjdXJpdHlPcmlnaW4+KTsKKyAgICBQZWVyQ29ubmVjdGlvbkhhbmRsZXIoUGVlckNvbm5l Y3Rpb25IYW5kbGVyQ2xpZW50KiwgY29uc3QgU3RyaW5nJiBzZXJ2ZXJDb25maWd1cmF0aW9uLCBj b25zdCBTdHJpbmcmIHVzZXJuYW1lKTsKIAogI2lmIFBMQVRGT1JNKENIUk9NSVVNKQogICAgIE93 blB0cjxQZWVyQ29ubmVjdGlvbkhhbmRsZXJJbnRlcm5hbD4gbV9wcml2YXRlOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vZ3N0cmVhbWVyL1BlZXJDb25u ZWN0aW9uSGFuZGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9n c3RyZWFtZXIvUGVlckNvbm5lY3Rpb25IYW5kbGVyLmNwcAppbmRleCA0NTY5YjVmZGI4MDA5OGMw ODc0Y2ZmYjk1MDVjODk3ODcwNjZmOTI0Li4zNzEyOTM0MTJkZTIyYjNlM2MzODNjYzMxYTFkNGIw N2E1NTJmMmNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVh bS9nc3RyZWFtZXIvUGVlckNvbm5lY3Rpb25IYW5kbGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9nc3RyZWFtZXIvUGVlckNvbm5lY3Rpb25IYW5kbGVyLmNw cApAQCAtMzUsMTggKzM1LDE2IEBACiAjaW5jbHVkZSAiUGVlckNvbm5lY3Rpb25IYW5kbGVyLmgi CiAKICNpbmNsdWRlICJQZWVyQ29ubmVjdGlvbkhhbmRsZXJDbGllbnQuaCIKLSNpbmNsdWRlICJT ZWN1cml0eU9yaWdpbi5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVBhc3NPd25QdHI8UGVl ckNvbm5lY3Rpb25IYW5kbGVyPiBQZWVyQ29ubmVjdGlvbkhhbmRsZXI6OmNyZWF0ZShQZWVyQ29u bmVjdGlvbkhhbmRsZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBzZXJ2ZXJDb25maWd1 cmF0aW9uLCBQYXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBzZWN1cml0eU9yaWdpbikKK1Bhc3NP d25QdHI8UGVlckNvbm5lY3Rpb25IYW5kbGVyPiBQZWVyQ29ubmVjdGlvbkhhbmRsZXI6OmNyZWF0 ZShQZWVyQ29ubmVjdGlvbkhhbmRsZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBzZXJ2 ZXJDb25maWd1cmF0aW9uLCBjb25zdCBTdHJpbmcmIHVzZXJuYW1lKQogewotICAgIHJldHVybiBh ZG9wdFB0cihuZXcgUGVlckNvbm5lY3Rpb25IYW5kbGVyKGNsaWVudCwgc2VydmVyQ29uZmlndXJh dGlvbiwgc2VjdXJpdHlPcmlnaW4pKTsKKyAgICByZXR1cm4gYWRvcHRQdHIobmV3IFBlZXJDb25u ZWN0aW9uSGFuZGxlcihjbGllbnQsIHNlcnZlckNvbmZpZ3VyYXRpb24sIHVzZXJuYW1lKSk7CiB9 CiAKLS8vIEZJWE1FOiByZW1vdmUgd2hlbiByZWFsIGltcGxlbWVudGF0aW9ucyBhcmUgYXZhaWxh YmxlCiAvLyBFbXB0eSBpbXBsZW1lbnRhdGlvbnMgZm9yIHBvcnRzIHRoYXQgYnVpbGQgd2l0aCBN RURJQV9TVFJFQU0gZW5hYmxlZCBieSBkZWZhdWx0LgotUGVlckNvbm5lY3Rpb25IYW5kbGVyOjpQ ZWVyQ29ubmVjdGlvbkhhbmRsZXIoUGVlckNvbm5lY3Rpb25IYW5kbGVyQ2xpZW50KiwgY29uc3Qg U3RyaW5nJiwgUGFzc1JlZlB0cjxTZWN1cml0eU9yaWdpbj4pCitQZWVyQ29ubmVjdGlvbkhhbmRs ZXI6OlBlZXJDb25uZWN0aW9uSGFuZGxlcihQZWVyQ29ubmVjdGlvbkhhbmRsZXJDbGllbnQqLCBj b25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmKQogewogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL2JyaWRnZS9QZWVyQ29ubmVjdGlvbkhhbmRsZXIuY3BwIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9icmlkZ2UvUGVlckNvbm5lY3Rpb25IYW5kbGVyLmNwcAppbmRleCBl OWJkOWU4MmQ4MjU4MWU3N2ZmMTcwYmJmOGE5ZDM2ZGNjMWZkZTNhLi5jNTliMmQ0NmNjMmM0NzA0 N2RlN2ZiZDJiZGEyMzI2YjFkZGRmOTg1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL2JyaWRnZS9QZWVyQ29ubmVjdGlvbkhhbmRsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vYnJpZGdlL1BlZXJDb25uZWN0aW9uSGFuZGxlci5jcHAKQEAgLTM2LDE3ICszNiwx NiBAQAogCiAjaW5jbHVkZSAiUGVlckNvbm5lY3Rpb25IYW5kbGVyQ2xpZW50LmgiCiAjaW5jbHVk ZSAiUGVlckNvbm5lY3Rpb25IYW5kbGVySW50ZXJuYWwuaCIKLSNpbmNsdWRlICJTZWN1cml0eU9y aWdpbi5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVBhc3NPd25QdHI8UGVlckNvbm5lY3Rp b25IYW5kbGVyPiBQZWVyQ29ubmVjdGlvbkhhbmRsZXI6OmNyZWF0ZShQZWVyQ29ubmVjdGlvbkhh bmRsZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBzZXJ2ZXJDb25maWd1cmF0aW9uLCBQ YXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBzZWN1cml0eU9yaWdpbikKK1Bhc3NPd25QdHI8UGVl ckNvbm5lY3Rpb25IYW5kbGVyPiBQZWVyQ29ubmVjdGlvbkhhbmRsZXI6OmNyZWF0ZShQZWVyQ29u bmVjdGlvbkhhbmRsZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBzZXJ2ZXJDb25maWd1 cmF0aW9uLCBjb25zdCBTdHJpbmcmIHVzZXJuYW1lKQogewotICAgIHJldHVybiBhZG9wdFB0cihu ZXcgUGVlckNvbm5lY3Rpb25IYW5kbGVyKGNsaWVudCwgc2VydmVyQ29uZmlndXJhdGlvbiwgc2Vj dXJpdHlPcmlnaW4pKTsKKyAgICByZXR1cm4gYWRvcHRQdHIobmV3IFBlZXJDb25uZWN0aW9uSGFu ZGxlcihjbGllbnQsIHNlcnZlckNvbmZpZ3VyYXRpb24sIHVzZXJuYW1lKSk7CiB9CiAKLVBlZXJD b25uZWN0aW9uSGFuZGxlcjo6UGVlckNvbm5lY3Rpb25IYW5kbGVyKFBlZXJDb25uZWN0aW9uSGFu ZGxlckNsaWVudCogY2xpZW50LCBjb25zdCBTdHJpbmcmIHNlcnZlckNvbmZpZ3VyYXRpb24sIFBh c3NSZWZQdHI8U2VjdXJpdHlPcmlnaW4+IHNlY3VyaXR5T3JpZ2luKQotICAgIDogbV9wcml2YXRl KGFkb3B0UHRyKG5ldyBQZWVyQ29ubmVjdGlvbkhhbmRsZXJJbnRlcm5hbChjbGllbnQsIHNlcnZl ckNvbmZpZ3VyYXRpb24sIHNlY3VyaXR5T3JpZ2luKSkpCitQZWVyQ29ubmVjdGlvbkhhbmRsZXI6 OlBlZXJDb25uZWN0aW9uSGFuZGxlcihQZWVyQ29ubmVjdGlvbkhhbmRsZXJDbGllbnQqIGNsaWVu dCwgY29uc3QgU3RyaW5nJiBzZXJ2ZXJDb25maWd1cmF0aW9uLCBjb25zdCBTdHJpbmcmIHVzZXJu YW1lKQorICAgIDogbV9wcml2YXRlKGFkb3B0UHRyKG5ldyBQZWVyQ29ubmVjdGlvbkhhbmRsZXJJ bnRlcm5hbChjbGllbnQsIHNlcnZlckNvbmZpZ3VyYXRpb24sIHVzZXJuYW1lKSkpCiB7CiB9CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vYnJpZGdlL1BlZXJDb25uZWN0aW9u SGFuZGxlckludGVybmFsLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vYnJpZGdlL1BlZXJD b25uZWN0aW9uSGFuZGxlckludGVybmFsLmNwcAppbmRleCBjZmMzMzU4NGFhMDIyNzQzZGJhYzEx OTMzNDY3ZGFhOThkYmM1NzRjLi5kOGY2MWY3ZjBiYmMwN2FlNGZkMGM4OWE3YTU0Mzg3NWMxZTJm OTY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL2JyaWRnZS9QZWVyQ29ubmVj dGlvbkhhbmRsZXJJbnRlcm5hbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9icmlk Z2UvUGVlckNvbm5lY3Rpb25IYW5kbGVySW50ZXJuYWwuY3BwCkBAIC00NSwxNSArNDUsMjEgQEAK IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QZWVyQ29ubmVjdGlvbkhhbmRsZXJJbnRlcm5hbDo6 UGVlckNvbm5lY3Rpb25IYW5kbGVySW50ZXJuYWwoUGVlckNvbm5lY3Rpb25IYW5kbGVyQ2xpZW50 KiBjbGllbnQsIGNvbnN0IFN0cmluZyYgc2VydmVyQ29uZmlndXJhdGlvbiwgUGFzc1JlZlB0cjxT ZWN1cml0eU9yaWdpbj4gc2VjdXJpdHlPcmlnaW4pCitQZWVyQ29ubmVjdGlvbkhhbmRsZXJJbnRl cm5hbDo6UGVlckNvbm5lY3Rpb25IYW5kbGVySW50ZXJuYWwoUGVlckNvbm5lY3Rpb25IYW5kbGVy Q2xpZW50KiBjbGllbnQsIGNvbnN0IFN0cmluZyYgc2VydmVyQ29uZmlndXJhdGlvbiwgY29uc3Qg U3RyaW5nJiB1c2VybmFtZSkKICAgICA6IG1fY2xpZW50KGNsaWVudCkKIHsKICAgICBBU1NFUlQo bV9jbGllbnQpOwogICAgIG1fd2ViSGFuZGxlciA9IGFkb3B0UHRyKFdlYktpdDo6d2ViS2l0UGxh dGZvcm1TdXBwb3J0KCktPmNyZWF0ZVBlZXJDb25uZWN0aW9uSGFuZGxlcih0aGlzKSk7CiAgICAg Ly8gRklYTUU6IFdoZW4gdGhlcmUgaXMgc29tZSBlcnJvciByZXBvcnRpbmcgYXZhbGlhYmxlIGlu IHRoZSBQZWVyQ29ubmVjdGlvbiBvYmplY3QgcmVwb3J0CiAgICAgLy8gaWYgd2UgZGlkbid0IGdl dCBhIFdlYlBlZXJDb25uZWN0aW9uSGFuZGxlciBpbnN0YW5jZS4KLSAgICBpZiAobV93ZWJIYW5k bGVyKQotICAgICAgICBtX3dlYkhhbmRsZXItPmluaXRpYWxpemUoc2VydmVyQ29uZmlndXJhdGlv biwgc2VjdXJpdHlPcmlnaW4pOworCisgICAgaWYgKG1fd2ViSGFuZGxlcikgeworICAgICAgICAv LyBEdWFsIGNhbGxzIGR1ZSB0byBBUEkgY2hhbmdlCisgICAgICAgIG1fd2ViSGFuZGxlci0+aW5p dGlhbGl6ZShzZXJ2ZXJDb25maWd1cmF0aW9uLCB1c2VybmFtZSk7CisKKyAgICAgICAgLy8gREVQ UkVDQVRFRAorICAgICAgICBtX3dlYkhhbmRsZXItPmluaXRpYWxpemUoc2VydmVyQ29uZmlndXJh dGlvbiwgU2VjdXJpdHlPcmlnaW46OmNyZWF0ZUZyb21TdHJpbmcodXNlcm5hbWUpKTsKKyAgICB9 CiB9CiAKIFBlZXJDb25uZWN0aW9uSGFuZGxlckludGVybmFsOjp+UGVlckNvbm5lY3Rpb25IYW5k bGVySW50ZXJuYWwoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9icmlkZ2Uv UGVlckNvbm5lY3Rpb25IYW5kbGVySW50ZXJuYWwuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v YnJpZGdlL1BlZXJDb25uZWN0aW9uSGFuZGxlckludGVybmFsLmgKaW5kZXggYTNlNzllMGFjYzNh ZmM0OWZiNjAyOGRmNjMwZWQzNGJmYjY2ODg5Zi4uZTE3ZmQ5NmI1YjVjNzFmOWFiOWMwYTNlMWVl Y2ZjYjdhZjUwY2FiMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9icmlkZ2Uv UGVlckNvbm5lY3Rpb25IYW5kbGVySW50ZXJuYWwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL2JyaWRnZS9QZWVyQ29ubmVjdGlvbkhhbmRsZXJJbnRlcm5hbC5oCkBAIC00OCwxMSArNDgs MTAgQEAgY2xhc3MgV2ViTWVkaWFTdHJlYW1EZXNjcmlwdG9yOwogbmFtZXNwYWNlIFdlYkNvcmUg ewogCiBjbGFzcyBQZWVyQ29ubmVjdGlvbkhhbmRsZXJDbGllbnQ7Ci1jbGFzcyBTZWN1cml0eU9y aWdpbjsKIAogY2xhc3MgUGVlckNvbm5lY3Rpb25IYW5kbGVySW50ZXJuYWwgOiBwdWJsaWMgV2Vi S2l0OjpXZWJQZWVyQ29ubmVjdGlvbkhhbmRsZXJDbGllbnQgewogcHVibGljOgotICAgIFBlZXJD b25uZWN0aW9uSGFuZGxlckludGVybmFsKFBlZXJDb25uZWN0aW9uSGFuZGxlckNsaWVudCosIGNv bnN0IFN0cmluZyYgc2VydmVyQ29uZmlndXJhdGlvbiwgUGFzc1JlZlB0cjxTZWN1cml0eU9yaWdp bj4pOworICAgIFBlZXJDb25uZWN0aW9uSGFuZGxlckludGVybmFsKFBlZXJDb25uZWN0aW9uSGFu ZGxlckNsaWVudCosIGNvbnN0IFN0cmluZyYgc2VydmVyQ29uZmlndXJhdGlvbiwgY29uc3QgU3Ry aW5nJiB1c2VybmFtZSk7CiAgICAgflBlZXJDb25uZWN0aW9uSGFuZGxlckludGVybmFsKCk7CiAK ICAgICB2aXJ0dWFsIHZvaWQgcHJvZHVjZUluaXRpYWxPZmZlcihjb25zdCBNZWRpYVN0cmVhbURl c2NyaXB0b3JWZWN0b3ImIHBlbmRpbmdBZGRTdHJlYW1zKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYlBlZXJDb25uZWN0aW9uSGFuZGxlci5o IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViUGVlckNvbm5lY3Rp b25IYW5kbGVyLmgKaW5kZXggNzU4NmFiYzAzODA4OGMyMzg5MDBjNTc2YTQ5NmY3YTQ1ZDdmMTVm Ny4uYmQyMDkzNTc3ZDE1YjQ1MTJkYjJiMTY3YTMzYjdlMjllNDY4YjM4YiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViUGVlckNvbm5lY3Rpb25I YW5kbGVyLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2Vi UGVlckNvbm5lY3Rpb25IYW5kbGVyLmgKQEAgLTU0LDcgKzU0LDEwIEBAIGNsYXNzIFdlYlBlZXJD b25uZWN0aW9uSGFuZGxlciB7CiBwdWJsaWM6CiAgICAgdmlydHVhbCB+V2ViUGVlckNvbm5lY3Rp b25IYW5kbGVyKCkgeyB9CiAKLSAgICB2aXJ0dWFsIHZvaWQgaW5pdGlhbGl6ZShjb25zdCBXZWJT dHJpbmcmIHNlcnZlckNvbmZpZ3VyYXRpb24sIGNvbnN0IFdlYlNlY3VyaXR5T3JpZ2luJikgPSAw OworICAgIC8vIERFUFJFQ0FURUQKKyAgICB2aXJ0dWFsIHZvaWQgaW5pdGlhbGl6ZShjb25zdCBX ZWJTdHJpbmcmIHNlcnZlckNvbmZpZ3VyYXRpb24sIGNvbnN0IFdlYlNlY3VyaXR5T3JpZ2luJikg eyB9OworCisgICAgdmlydHVhbCB2b2lkIGluaXRpYWxpemUoY29uc3QgV2ViU3RyaW5nJiBzZXJ2 ZXJDb25maWd1cmF0aW9uLCBjb25zdCBXZWJTdHJpbmcmIHVzZXJuYW1lKSB7IH07CiAKICAgICB2 aXJ0dWFsIHZvaWQgcHJvZHVjZUluaXRpYWxPZmZlcihjb25zdCBXZWJWZWN0b3I8V2ViTWVkaWFT dHJlYW1EZXNjcmlwdG9yPiYgcGVuZGluZ0FkZFN0cmVhbXMpID0gMDsKICAgICB2aXJ0dWFsIHZv aWQgaGFuZGxlSW5pdGlhbE9mZmVyKGNvbnN0IFdlYlN0cmluZyYgc2RwKSA9IDA7Cg==