223511 2021-03-19 06:48:07 -0700 GraphicsContextGLOpenGL should avoid calling into ANGLE MakeCurrent 2021-03-26 08:34:54 -0700 1 1 1 Unclassified WebKit WebGL Other Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 223434 1 kkinnunen kkinnunen dino ews-watchlist graouts kbr kkinnunen kondapallykalyan simon.fraser webkit-bug-importer oldest_to_newest 1741680 0 kkinnunen 2021-03-19 06:48:07 -0700 GraphicsContextGLOpenGL should avoid calling into ANGLE MakeCurrent The function is fairly expensive. 1741682 1 423726 kkinnunen 2021-03-19 06:52:13 -0700 Created attachment 423726 Patch 1741725 2 423726 simon.fraser 2021-03-19 09:11:51 -0700 Comment on attachment 423726 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=423726&action=review > Source/WebCore/ChangeLog:11 > + This can be done when run in WebContent process or in GPU process, > + but not when in WK1. Why? Could you explain this here? > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:55 > +static bool isCurrentContextPredictable() > +{ > + static bool value = isInWebProcess() || isInGPUProcess(); > + return value; > +} This is pretty mysterious. What is it about being in the web process or GPU process that makes this possible? Is it that we know there are no other clients of ANGLE? 1741730 3 simon.fraser 2021-03-19 09:18:11 -0700 Why can't ANGLE just do this optimization for us? 1741753 4 kkinnunen 2021-03-19 10:00:12 -0700 WK1 runs third-party code in the thread that it runs WebKit code. That code can switch EAGL contexts behind WebKit's/ANGLE's back. That's what the existing volatile context code already is (and as such there's no *new* emphasis about the issue) 1741760 5 kkinnunen 2021-03-19 10:03:52 -0700 (In reply to Simon Fraser (smfr) from comment #3) > Why can't ANGLE just do this optimization for us? ANGLE needs to be thread safe and there's other semantics to MakeCurrent. (ANGLE doesn't necessarily respect all the other semantics, though). It's a bit surprising the first point is such expensive. EGLBoolean EGLAPIENTRY EGL_MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) { ANGLE_SCOPED_GLOBAL_LOCK(); FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface draw = 0x%016" PRIxPTR ", EGLSurface read = 0x%016" PRIxPTR ", " "EGLContext ctx = %d", (uintptr_t)dpy, (uintptr_t)draw, (uintptr_t)read, CID(dpy, ctx)); Thread *thread = egl::GetCurrentThread(); egl::Display *display = static_cast<egl::Display *>(dpy); Surface *drawSurface = static_cast<Surface *>(draw); Surface *readSurface = static_cast<Surface *>(read); gl::Context *context = static_cast<gl::Context *>(ctx); ANGLE_EGL_TRY_RETURN(thread, ValidateMakeCurrent(display, drawSurface, readSurface, context), "eglMakeCurrent", GetContextIfValid(display, context), EGL_FALSE); ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglMakeCurrent", GetDisplayIfValid(display), EGL_FALSE); Surface *previousDraw = thread->getCurrentDrawSurface(); Surface *previousRead = thread->getCurrentReadSurface(); gl::Context *previousContext = thread->getContext(); // Only call makeCurrent if the context or surfaces have changed. if (previousDraw != drawSurface || previousRead != readSurface || previousContext != context) { ANGLE_EGL_TRY_RETURN(thread, display->makeCurrent(thread, drawSurface, readSurface, context), "eglMakeCurrent", GetContextIfValid(display, context), EGL_FALSE); SetContextCurrent(thread, context); } thread->setSuccess(); return EGL_TRUE; } 1741828 6 423726 kbr 2021-03-19 12:10:46 -0700 Comment on attachment 423726 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=423726&action=review I agree with Simon that it's unfortunate this optimization is needed. Would you consider reaching out to the ANGLE developers on Slack to see whether we can instead optimize ANGLE's EGL_MakeCurrent? Maybe we can instead optimize its global lock management and/or thread-local variables using cheaper intrinsics to maintain complete correctness and still get a good speed boost. Regardless, setting r+ to unblock you since this is a significant performance increase. Also - agree that moving to using ANGLE's explicit context entry points would be great, and probably a big win. > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:49 > +static GraphicsContextGLOpenGL* currentContext; As soon as WebKit supports rendering to OffscreenCanvas from web workers, this optimization will break. Are you sure you want to go in this direction? At least I think it would be worth filing a bug and adding a FIXME or similar about it. 1741829 7 423726 kbr 2021-03-19 12:13:59 -0700 Comment on attachment 423726 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=423726&action=review > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:428 > + if (!m_needsMakeCurrent) Actually, hang on. If you're rendering WebGL into two different canvases simultaneously and alternating the calls between the contexts then you have to check if this == currentContext as the first condition, right? 1741830 8 kbr 2021-03-19 12:14:31 -0700 (Removed my r+ because not sure this is correct any more) 1742154 9 kkinnunen 2021-03-22 01:34:44 -0700 (In reply to Kenneth Russell from comment #6) > Also - agree that moving to using ANGLE's explicit context entry points > would be great, and probably a big win. That's what I thought, but looking at the explicit context implementation, isn't it just side-stepping a global variable load ? (I've fixed the bugs in WebKit ANGLE integration to be able to use explicit context) > > > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:49 > > +static GraphicsContextGLOpenGL* currentContext; > > As soon as WebKit supports rendering to OffscreenCanvas from web workers, > this optimization will break. Are you sure you want to go in this direction? > At least I think it would be worth filing a bug and adding a FIXME or > similar about it. You mean as soon as WebKit supports rendering to OffscreenCanvas from web worker which is executing in different thread? I don't think we have multi-threaded ANGLE, right? E.g. in that scenario, ANGLE cannot be called into from simultaneous threads, making this point moot? 1742156 10 423726 kkinnunen 2021-03-22 01:38:29 -0700 Comment on attachment 423726 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=423726&action=review > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:435 > + currentContext->m_needsMakeCurrent = true; When the target canvas changes, this is intended to take care of the case you're indicating. 1742169 11 423866 kkinnunen 2021-03-22 03:05:22 -0700 Created attachment 423866 Patch 1742170 12 kkinnunen 2021-03-22 03:07:06 -0700 I think the previous was correct but it rised too many questions for it to be ok. How about this one? I replaced the m_needsMakeCurrent with a comment explaining why it's ok to access the global variable. 1742640 13 423866 kbr 2021-03-22 18:59:58 -0700 Comment on attachment 423866 Patch Thanks for the update. I didn't understand how the previous code worked because there's a separate GraphicsContextGL instance for each WebGLRenderingContext, but this is much clearer. r+ Hopefully the webgl/conformance/extensions/khr-parallel-shader-compile.html failure on ios-wk2, unrelated to this, has been suppressed. 1742642 14 kbr 2021-03-22 19:07:38 -0700 (In reply to Kimmo Kinnunen from comment #9) > You mean as soon as WebKit supports rendering to OffscreenCanvas from web > worker which is executing in different thread? > > I don't think we have multi-threaded ANGLE, right? E.g. in that scenario, > ANGLE cannot be called into from simultaneous threads, making this point > moot? I see now (more clearly from the latest patch set) that this is hidden entirely in the Cocoa implementation of GraphicsContextGL, so will go away when using the GPU process. Never mind this concern then. I agree we won't have full multi-threaded ANGLE any time soon nor need to use it for this scenario. 1744154 15 webkit-bug-importer 2021-03-26 06:49:15 -0700 <rdar://problem/75884571> 1744182 16 ews-feeder 2021-03-26 08:34:52 -0700 Committed r275097: <https://commits.webkit.org/r275097> All reviewed patches have been landed. Closing bug and clearing flags on attachment 423866. 423726 2021-03-19 06:52:13 -0700 2021-03-22 03:05:16 -0700 Patch bug-223511-20210319155212.patch text/plain 6680 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjc0NjQwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2FiYTI5NWE4NGQ1NDU2 NTg1OTM5Y2VkYmIxYTRjMzhiNDhhNjg0Ny4uOTg4MDYwZmYyODE2MmI2N2FmZGQ1Y2FmYzBjYjhh MWM4YjQ0ZDMyNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDIxLTAzLTE5ICBLaW1t byBLaW5udW5lbiAgPGtraW5udW5lbkBhcHBsZS5jb20+CisKKyAgICAgICAgR3JhcGhpY3NDb250 ZXh0R0xPcGVuR0wgc2hvdWxkIGF2b2lkIGNhbGxpbmcgaW50byBBTkdMRSBNYWtlQ3VycmVudAor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjIzNTExCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQXZvaWQgY2Fs bGluZyBBTkdMRSBNYWtlQ3VycmVudCBmb3IgY29udGV4dHMgdGhhdCBhcmUgYWxyZWFkeSBjdXJy ZW50LgorCisgICAgICAgIFRoaXMgY2FuIGJlIGRvbmUgd2hlbiBydW4gaW4gV2ViQ29udGVudCBw cm9jZXNzIG9yIGluIEdQVSBwcm9jZXNzLAorICAgICAgICBidXQgbm90IHdoZW4gaW4gV0sxLgor CisgICAgICAgIE1ha2VzIGluLXByb2Nlc3MgV2ViR0wgZmFzdGVyIGluIE1vdGlvbk1hcmsgdHJp YW5nbGVzIGJ5IDYzMDAgLT4gOTgwMCBwdHMKKyAgICAgICAgTWFrZXMgR1BVIHByb2Nlc3MgV2Vi R0wgZmFzdGVyIGluIE1vdGlvbk1hcmsgdHJpYW5nbGVzIGJ5IDUzMDAgLT4gNzAwMCBwdHMKKwor ICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2NvY29hL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdM Q29jb2EubW06CisgICAgICAgIChXZWJDb3JlOjppc0N1cnJlbnRDb250ZXh0UHJlZGljdGFibGUp OgorICAgICAgICAoV2ViQ29yZTo6SW5pdGlhbGl6ZUVHTERpc3BsYXkpOgorICAgICAgICAoV2Vi Q29yZTo6R3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6On5HcmFwaGljc0NvbnRleHRHTE9wZW5HTCk6 CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6bWFrZUNvbnRleHRD dXJyZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpjbGVh ckN1cnJlbnRDb250ZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3Bl bkdMOjpyZWxlYXNlQ3VycmVudENvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3ND b250ZXh0R0xPcGVuR0w6OmNoZWNrR1BVU3RhdHVzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wuaDoKKwogMjAyMS0wMy0xOCAgS2lt bW8gS2lubnVuZW4gIDxra2lubnVuZW5AYXBwbGUuY29tPgogCiAgICAgICAgIEFOR0xFIGlzIG1p c3NpbmcgdGhlIGV4cGxpY2l0IGNvbnRleHQgaGVhZGVycwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0xDb2Nv YS5tbSBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NvY29hL0dyYXBoaWNzQ29u dGV4dEdMT3BlbkdMQ29jb2EubW0KaW5kZXggNzIwOGM5MDMwNTA0Yzc5MDdkYjdmNDc4ODgxOTJm MDUzZTg5M2NiNi4uMTQ0NzE4Yzk5MjZiZmNkNjBjNjM4YzlkZWE0YmEyZjM4NjAxOGExZCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvR3JhcGhpY3ND b250ZXh0R0xPcGVuR0xDb2NvYS5tbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jb2NvYS9HcmFwaGljc0NvbnRleHRHTE9wZW5HTENvY29hLm1tCkBAIC00Niw2ICs0Niwx NCBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK3N0YXRpYyBHcmFwaGljc0NvbnRleHRHTE9w ZW5HTCogY3VycmVudENvbnRleHQ7CisKK3N0YXRpYyBib29sIGlzQ3VycmVudENvbnRleHRQcmVk aWN0YWJsZSgpCit7CisgICAgc3RhdGljIGJvb2wgdmFsdWUgPSBpc0luV2ViUHJvY2VzcygpIHx8 IGlzSW5HUFVQcm9jZXNzKCk7CisgICAgcmV0dXJuIHZhbHVlOworfQorCiAjaWYgQVNTRVJUX0VO QUJMRUQKIC8vIFJldHVybnMgdHJ1ZSBpZiB3ZSBoYXZlIHZvbGF0aWxlIGNvbnRleHQgZXh0ZW5z aW9uIGZvciB0aGUgcGFydGljdWxhciBBUEkgb3IKIC8vIGlmIHRoZSBwYXJ0aWN1bGFyIEFQSSBp cyBub3QgdXNlZC4KQEAgLTc5LDcgKzg3LDcgQEAgc3RhdGljIFNjb3BlZEVHTERlZmF1bHREaXNw bGF5IEluaXRpYWxpemVFR0xEaXNwbGF5KGNvbnN0IEdyYXBoaWNzQ29udGV4dEdMQXR0cmkKICAg ICBWZWN0b3I8RUdMaW50PiBkaXNwbGF5QXR0cmlidXRlczsKIAogICAgIC8vIEZJWE1FOiBUaGlz IHNob3VsZCBjb21lIGluIGZyb20gdGhlIEdyYXBoaWNzQ29udGV4dEdMQXR0cmlidXRlcy4KLSAg ICBib29sIHNob3VsZEluaXRpYWxpemVXaXRoVm9sYXRpbGVDb250ZXh0U3VwcG9ydCA9ICEoaXNJ bldlYlByb2Nlc3MoKSB8fCBpc0luR1BVUHJvY2VzcygpKTsKKyAgICBib29sIHNob3VsZEluaXRp YWxpemVXaXRoVm9sYXRpbGVDb250ZXh0U3VwcG9ydCA9ICFpc0N1cnJlbnRDb250ZXh0UHJlZGlj dGFibGUoKTsKICAgICBpZiAoc2hvdWxkSW5pdGlhbGl6ZVdpdGhWb2xhdGlsZUNvbnRleHRTdXBw b3J0KSB7CiAgICAgICAgIC8vIEZvciBXSzEgdHlwZSBBUElzIHdlIG5lZWQgdG8gc2V0ICJ2b2xh dGlsZSBwbGF0Zm9ybSBjb250ZXh0IiBmb3Igc3BlY2lmaWMKICAgICAgICAgLy8gQVBJcywgc2lu Y2UgY2xpZW50IGNvZGUgd2lsbCBiZSBhYmxlIHRvIG92ZXJyaWRlIHRoZSB0aHJlYWQtZ2xvYmFs IGNvbnRleHQKQEAgLTM2MCwxMCArMzY4LDEzIEBAIEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjp+ R3JhcGhpY3NDb250ZXh0R0xPcGVuR0woKQogICAgICAgICAgICAgRUdMX0Rlc3Ryb3lTdXJmYWNl KG1fZGlzcGxheU9iaiwgY29udGVudHNIYW5kbGUpOwogICAgIH0KICAgICBpZiAobV9jb250ZXh0 T2JqKSB7Ci0gICAgICAgIEVHTF9NYWtlQ3VycmVudChtX2Rpc3BsYXlPYmosIEVHTF9OT19TVVJG QUNFLCBFR0xfTk9fU1VSRkFDRSwgRUdMX05PX0NPTlRFWFQpOworICAgICAgICBjbGVhckN1cnJl bnRDb250ZXh0KCk7CiAgICAgICAgIEVHTF9EZXN0cm95Q29udGV4dChtX2Rpc3BsYXlPYmosIG1f Y29udGV4dE9iaik7CiAgICAgfQotCisgICAgaWYgKGlzQ3VycmVudENvbnRleHRQcmVkaWN0YWJs ZSgpKSB7CisgICAgICAgIGlmIChjdXJyZW50Q29udGV4dCA9PSB0aGlzKQorICAgICAgICAgICAg Y3VycmVudENvbnRleHQgPSBudWxscHRyOworICAgIH0KICAgICBMT0coV2ViR0wsICJEZXN0cm95 ZWQgYSBHcmFwaGljc0NvbnRleHRHTE9wZW5HTCAoJXApLiIsIHRoaXMpOwogfQogCkBAIC00MTQs MTggKzQyNSwzNyBAQCBib29sIEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjptYWtlQ29udGV4dEN1 cnJlbnQoKQogICAgIC8vIFRoZSBleGNlcHRpb24gaXMgdGhlIGNhc2Ugd2hlbiB0aGUgY29udGV4 dCBpcyB1c2VkIGJlZm9yZSByZXNoYXBpbmcuCiAgICAgaWYgKCFtX2Rpc3BsYXlCdWZmZXJCYWNr aW5nICYmICFnZXRJbnRlcm5hbEZyYW1lYnVmZmVyU2l6ZSgpLmlzRW1wdHkoKSkKICAgICAgICAg cmV0dXJuIGZhbHNlOwotICAgIC8vIEFOR0xFIGhhcyBhbiBlYXJseSBvdXQgZm9yIGNhc2Ugd2hl cmUgbm90aGluZyBjaGFuZ2VzLiBDYWxsaW5nIE1ha2VDdXJyZW50Ci0gICAgLy8gaXMgaW1wb3J0 YW50IHRvIHNldCB2b2xhdGlsZSBwbGF0Zm9ybSBjb250ZXh0LiBTZWUgSW5pdGlhbGl6ZUVHTERp c3BsYXkoKS4KKyAgICBpZiAoIW1fbmVlZHNNYWtlQ3VycmVudCkKKyAgICAgICAgcmV0dXJuIHRy dWU7CisgICAgLy8gQ2FsbGluZyBNYWtlQ3VycmVudCBpcyBpbXBvcnRhbnQgdG8gc2V0IHZvbGF0 aWxlIHBsYXRmb3JtIGNvbnRleHQuIFNlZSBJbml0aWFsaXplRUdMRGlzcGxheSgpLgogICAgIGlm ICghRUdMX01ha2VDdXJyZW50KG1fZGlzcGxheU9iaiwgRUdMX05PX1NVUkZBQ0UsIEVHTF9OT19T VVJGQUNFLCBtX2NvbnRleHRPYmopKQogICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgaWYgKGlz Q3VycmVudENvbnRleHRQcmVkaWN0YWJsZSgpKSB7CisgICAgICAgIGlmIChjdXJyZW50Q29udGV4 dCkKKyAgICAgICAgICAgIGN1cnJlbnRDb250ZXh0LT5tX25lZWRzTWFrZUN1cnJlbnQgPSB0cnVl OworICAgICAgICBjdXJyZW50Q29udGV4dCA9IHRoaXM7CisgICAgICAgIG1fbmVlZHNNYWtlQ3Vy cmVudCA9IGZhbHNlOworICAgIH0KICAgICByZXR1cm4gdHJ1ZTsKIH0KIAordm9pZCBHcmFwaGlj c0NvbnRleHRHTE9wZW5HTDo6Y2xlYXJDdXJyZW50Q29udGV4dCgpCit7CisgICAgRUdMQm9vbGVh biByZXN1bHQgPSBFR0xfTWFrZUN1cnJlbnQobV9kaXNwbGF5T2JqLCBFR0xfTk9fU1VSRkFDRSwg RUdMX05PX1NVUkZBQ0UsIEVHTF9OT19DT05URVhUKTsKKyAgICBBU1NFUlRfVU5VU0VEKHJlc3Vs dCwgcmVzdWx0KTsKKyAgICBpZiAoaXNDdXJyZW50Q29udGV4dFByZWRpY3RhYmxlKCkpIHsKKyAg ICAgICAgaWYgKGN1cnJlbnRDb250ZXh0KSB7CisgICAgICAgICAgICBjdXJyZW50Q29udGV4dC0+ bV9uZWVkc01ha2VDdXJyZW50ID0gdHJ1ZTsKKyAgICAgICAgICAgIGN1cnJlbnRDb250ZXh0ID0g bnVsbHB0cjsKKyAgICAgICAgfQorICAgIH0KK30KKwogI2lmIFBMQVRGT1JNKElPU19GQU1JTFkp CiBib29sIEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpyZWxlYXNlQ3VycmVudENvbnRleHQoUmVs ZWFzZUJlaGF2aW9yIHJlbGVhc2VCZWhhdmlvcikKIHsKICAgICAvLyBBdCB0aGUgbW9tZW50IHRo aXMgZnVuY3Rpb24gaXMgcmVsZXZhbnQgb25seSB3aGVuIHdlYiB0aHJlYWQgbG9jayBvd25zIHRo ZSBHcmFwaGljc0NvbnRleHRHTE9wZW5HTCBjdXJyZW50IGNvbnRleHQuCi0gICAgQVNTRVJUKCFX ZWJDb3JlOjppc0luV2ViUHJvY2VzcygpKTsKKyAgICBBU1NFUlQoIWlzQ3VycmVudENvbnRleHRQ cmVkaWN0YWJsZSgpKTsKIAogICAgIGlmICghRUdMX0JpbmRBUEkoRUdMX09QRU5HTF9FU19BUEkp KQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC00NjMsOSArNDkzLDcgQEAgdm9pZCBHcmFwaGlj c0NvbnRleHRHTE9wZW5HTDo6Y2hlY2tHUFVTdGF0dXMoKQogICAgICAgICBMT0coV2ViR0wsICJQ cmV0ZW5kaW5nIHRoZSBHUFUgaGFzIHJlc2V0ICglcCkuIExvc2UgdGhlIGNvbnRleHQuIiwgdGhp cyk7CiAgICAgICAgIG1fZmFpbE5leHRTdGF0dXNDaGVjayA9IGZhbHNlOwogICAgICAgICBmb3Jj ZUNvbnRleHRMb3N0KCk7Ci0KLSAgICAgICAgRUdMX0JpbmRBUEkoRUdMX09QRU5HTF9FU19BUEkp OwotICAgICAgICBFR0xfTWFrZUN1cnJlbnQobV9kaXNwbGF5T2JqLCBFR0xfTk9fU1VSRkFDRSwg RUdMX05PX1NVUkZBQ0UsIEVHTF9OT19DT05URVhUKTsKKyAgICAgICAgY2xlYXJDdXJyZW50Q29u dGV4dCgpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wuaCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHRH TE9wZW5HTC5oCmluZGV4IDVlMzMwNzc4OWY5MGRiMWE2ZTI3MWU0YjMyYzQzZDExMTg0YWM2Mzku LmZhNTdiZmZiYTUyYWUwYTMzY2ZmZjdiMDBjYjAzN2IwODRlZjZhMzAgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHRHTE9w ZW5HTC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFw aGljc0NvbnRleHRHTE9wZW5HTC5oCkBAIC01MzYsNiArNTM2LDcgQEAgcHJpdmF0ZToKICAgICAv LyBDYWxsZWQgb25jZSBieSBhbGwgdGhlIHB1YmxpYyBlbnRyeSBwb2ludHMgdGhhdCBldmVudHVh bGx5IGNhbGwgT3BlbkdMLgogICAgIC8vIENhbGxlZCBvbmNlIGJ5IGFsbCB0aGUgcHVibGljIGVu dHJ5IHBvaW50cyBvZiBFeHRlbnNpb25zR0wgdGhhdCBldmVudHVhbGx5IGNhbGwgT3BlbkdMLgog ICAgIGJvb2wgbWFrZUNvbnRleHRDdXJyZW50KCkgV0FSTl9VTlVTRURfUkVUVVJOOworICAgIHZv aWQgY2xlYXJDdXJyZW50Q29udGV4dCgpOwogCiAgICAgLy8gVGFrZSBpbnRvIGFjY291bnQgdGhl IHVzZXIncyByZXF1ZXN0ZWQgY29udGV4dCBjcmVhdGlvbiBhdHRyaWJ1dGVzLAogICAgIC8vIGlu IHBhcnRpY3VsYXIgc3RlbmNpbCBhbmQgYW50aWFsaWFzLCBhbmQgZGV0ZXJtaW5lIHdoaWNoIGNv dWxkIG9yCkBAIC01NzIsNiArNTczLDcgQEAgcHJpdmF0ZToKICAgICBTY29wZWRFR0xEZWZhdWx0 RGlzcGxheSBtX2Rpc3BsYXlPYmo7CiAgICAgUGxhdGZvcm1HcmFwaGljc0NvbnRleHRHTCBtX2Nv bnRleHRPYmogeyBudWxscHRyIH07CiAgICAgUGxhdGZvcm1HcmFwaGljc0NvbnRleHRHTENvbmZp ZyBtX2NvbmZpZ09iaiB7IG51bGxwdHIgfTsKKyAgICBib29sIG1fbmVlZHNNYWtlQ3VycmVudCB7 IHRydWUgfTsKICNlbmRpZiAvLyBQTEFURk9STShDT0NPQSkKIAogI2lmIFBMQVRGT1JNKFdJTikg JiYgVVNFKENBKQo= 423866 2021-03-22 03:05:22 -0700 2021-03-26 08:34:53 -0700 Patch bug-223511-20210322120520.patch text/plain 6982 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjc0NzUwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWQ5MjI2OTk4MWQ3OWQy YjFmZjcwMjhmZGUyOGEwMGU3YzQ0MzdmMi4uMTVkMTM0YjE2MWE2MWJmYzkxMjFkN2I5ZDI4M2Yx MDJiZDRlNzRmNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMxIEBACisyMDIxLTAzLTIyICBLaW1t byBLaW5udW5lbiAgPGtraW5udW5lbkBhcHBsZS5jb20+CisKKyAgICAgICAgR3JhcGhpY3NDb250 ZXh0R0xPcGVuR0wgc2hvdWxkIGF2b2lkIGNhbGxpbmcgaW50byBBTkdMRSBNYWtlQ3VycmVudAor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjIzNTExCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQXZvaWQgY2Fs bGluZyBBTkdMRSBNYWtlQ3VycmVudCBmb3IgY29udGV4dHMgdGhhdCBhcmUgYWxyZWFkeSBjdXJy ZW50LiBDYWNoZSB0aGUgY3VycmVudCBjb250ZXh0IHBvaW50ZXIgaW50byBhCisgICAgICAgIGds b2JhbCB2YXJpYWJsZS4gQ3VycmVudGx5IHRoZSBjb2RlIGFkZHMgbm8gbG9ja2luZy4gRm9yIHRo ZSBmb3JzZWVhYmxlIGZ1dHVyZSwgQU5HTEUgZG9lcyBub3Qgc3VwcG9ydAorICAgICAgICBzaW11 bHRhbmVvdXMgYWNjZXNzIGZyb20gbXVsdGlwbGUgdGhyZWFkcy4KKworICAgICAgICBUaGUgb3B0 aW1pemF0aW9uIGNhbiBiZSBkb25lIHdoZW4gcnVuIGluIFdlYkNvbnRlbnQgcHJvY2VzcyBvciBp biBHUFUgcHJvY2VzcywgYnV0IG5vdCB3aGVuIGluIFdLMS4gVGhpcyBpcyBiZWNhdXNlIGluIFdL MSwKKyAgICAgICAgdGhlIDNyZCBwYXJ0eSBjbGllbnQgbWF5IHJ1biBhcmJpdHJhcnkgY29kZSBp biBXZWJLaXQgdGhyZWFkLiBUaGlzIGluY2x1ZGVzIGNvZGUgdGhhdCBjaGFuZ2VzIEVBR0wgb3Ig QUdMIHN0YXRlLgorICAgICAgICBUaGlzIGNvZGUgbWlnaHQgY2hhbmdlIHRoZSBjdXJyZW50IGNv bnRleHQgdW5kZXJuZWF0aCBXZWJLaXQuIEluIFdLMSBtb2RlLCB3ZSBhbHJlYWR5IHVzZSAidm9s YXRpbGUgY29udGV4dCIgZmVhdHVyZSBvZgorICAgICAgICBBTkdMRSB0byByZXNldCB0aGUgcGxh dGZvcm0gY29udGV4dCBvbiBldmVyeSBFR0wgY29tbWFuZC4gVGhlIGNvbW1hbmQgd2UgdXNlIGZv ciB0aGlzIGZvciBub3JtYWwgR0wgY29tbWFuZHMgaXMgRUdMX01ha2VDdXJyZW50LgorICAgICAg ICBNYWtlcyBpbi1wcm9jZXNzIFdlYkdMIGZhc3RlciBpbiBNb3Rpb25NYXJrIHRyaWFuZ2xlcyBi eSA2MzAwIC0+IDk4MDAgcHRzCisgICAgICAgIE1ha2VzIEdQVSBwcm9jZXNzIFdlYkdMIGZhc3Rl ciBpbiBNb3Rpb25NYXJrIHRyaWFuZ2xlcyBieSA1MzAwIC0+IDcwMDAgcHRzCisKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9HcmFwaGljc0NvbnRleHRHTE9wZW5HTENvY29hLm1t OgorICAgICAgICAoV2ViQ29yZTo6aXNDdXJyZW50Q29udGV4dFByZWRpY3RhYmxlKToKKyAgICAg ICAgKFdlYkNvcmU6OkluaXRpYWxpemVFR0xEaXNwbGF5KToKKyAgICAgICAgKFdlYkNvcmU6Okdy YXBoaWNzQ29udGV4dEdMT3BlbkdMOjp+R3JhcGhpY3NDb250ZXh0R0xPcGVuR0wpOgorICAgICAg ICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6Om1ha2VDb250ZXh0Q3VycmVudCk6 CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6Y2xlYXJDdXJyZW50 Q29udGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6cmVs ZWFzZUN1cnJlbnRDb250ZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdM T3BlbkdMOjpjaGVja0dQVVN0YXR1cyk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvb3Bl bmdsL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmg6CisKIDIwMjEtMDMtMTkgIERlYW4gSmFja3Nv biAgPGRpbm9AYXBwbGUuY29tPgogCiAgICAgICAgIExpbmsgYWdhaW5zdCB0aGUgQU5HTEUgU2hh cmVkIExpYnJhcnkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2NvY29hL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMQ29jb2EubW0gYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9HcmFwaGljc0NvbnRleHRHTE9wZW5HTENvY29hLm1tCmlu ZGV4IGQwMTk1N2U2YTQ0MmI4NGE0MzhmMTRiNTY4N2U5YTJkMmRkY2MyN2MuLjRhN2VmZDFhZmUz ZTAzYjVhY2QyM2YxNDEwMDI0ZjI2MDUzODZjMjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2NvY29hL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMQ29jb2EubW0K KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvR3JhcGhpY3NDb250 ZXh0R0xPcGVuR0xDb2NvYS5tbQpAQCAtNDksNiArNDksMTcgQEAgV1RGX1dFQUtfTElOS19GT1JD RV9JTVBPUlQoRUdMX0luaXRpYWxpemUpOwogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKKy8vIElu IGlzQ3VycmVudENvbnRleHRQcmVkaWN0YWJsZSgpID09IHRydWUgY2FzZSB0aGlzIHZhcmlhYmxl IGlzIGFjY2Vzc2VkIGluIHNpbmdsZS10aHJlYWRlZCBtYW5uZXIuCisvLyBJbiBpc0N1cnJlbnRD b250ZXh0UHJlZGljdGFibGUoKSA9PSBmYWxzZSBjYXNlIHRoaXMgdmFyaWFibGUgaXMgYWNjZXNz ZWQgZnJvbSBtdWx0aXBsZSB0aHJlYWRzIGJ1dCBhbHdheXMgc2VxdWVudGlhbGx5CisvLyBhbmQg aXQgYWx3YXlzIGNvbnRhaW5zIG51bGxwdHIgYW5kIG51bGxwdHIgaXMgYWx3YXlzIHdyaXR0ZW4g dG8gaXQuCitzdGF0aWMgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wqIGN1cnJlbnRDb250ZXh0Owor CitzdGF0aWMgYm9vbCBpc0N1cnJlbnRDb250ZXh0UHJlZGljdGFibGUoKQoreworICAgIHN0YXRp YyBib29sIHZhbHVlID0gaXNJbldlYlByb2Nlc3MoKSB8fCBpc0luR1BVUHJvY2VzcygpOworICAg IHJldHVybiB2YWx1ZTsKK30KKwogI2lmIEFTU0VSVF9FTkFCTEVECiAvLyBSZXR1cm5zIHRydWUg aWYgd2UgaGF2ZSB2b2xhdGlsZSBjb250ZXh0IGV4dGVuc2lvbiBmb3IgdGhlIHBhcnRpY3VsYXIg QVBJIG9yCiAvLyBpZiB0aGUgcGFydGljdWxhciBBUEkgaXMgbm90IHVzZWQuCkBAIC04Miw3ICs5 Myw3IEBAIHN0YXRpYyBTY29wZWRFR0xEZWZhdWx0RGlzcGxheSBJbml0aWFsaXplRUdMRGlzcGxh eShjb25zdCBHcmFwaGljc0NvbnRleHRHTEF0dHJpCiAgICAgVmVjdG9yPEVHTGludD4gZGlzcGxh eUF0dHJpYnV0ZXM7CiAKICAgICAvLyBGSVhNRTogVGhpcyBzaG91bGQgY29tZSBpbiBmcm9tIHRo ZSBHcmFwaGljc0NvbnRleHRHTEF0dHJpYnV0ZXMuCi0gICAgYm9vbCBzaG91bGRJbml0aWFsaXpl V2l0aFZvbGF0aWxlQ29udGV4dFN1cHBvcnQgPSAhKGlzSW5XZWJQcm9jZXNzKCkgfHwgaXNJbkdQ VVByb2Nlc3MoKSk7CisgICAgYm9vbCBzaG91bGRJbml0aWFsaXplV2l0aFZvbGF0aWxlQ29udGV4 dFN1cHBvcnQgPSAhaXNDdXJyZW50Q29udGV4dFByZWRpY3RhYmxlKCk7CiAgICAgaWYgKHNob3Vs ZEluaXRpYWxpemVXaXRoVm9sYXRpbGVDb250ZXh0U3VwcG9ydCkgewogICAgICAgICAvLyBGb3Ig V0sxIHR5cGUgQVBJcyB3ZSBuZWVkIHRvIHNldCAidm9sYXRpbGUgcGxhdGZvcm0gY29udGV4dCIg Zm9yIHNwZWNpZmljCiAgICAgICAgIC8vIEFQSXMsIHNpbmNlIGNsaWVudCBjb2RlIHdpbGwgYmUg YWJsZSB0byBvdmVycmlkZSB0aGUgdGhyZWFkLWdsb2JhbCBjb250ZXh0CkBAIC0zNzMsMTAgKzM4 NCwxMCBAQCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6fkdyYXBoaWNzQ29udGV4dEdMT3BlbkdM KCkKICAgICAgICAgICAgIEVHTF9EZXN0cm95U3VyZmFjZShtX2Rpc3BsYXlPYmosIGNvbnRlbnRz SGFuZGxlKTsKICAgICB9CiAgICAgaWYgKG1fY29udGV4dE9iaikgewotICAgICAgICBFR0xfTWFr ZUN1cnJlbnQobV9kaXNwbGF5T2JqLCBFR0xfTk9fU1VSRkFDRSwgRUdMX05PX1NVUkZBQ0UsIEVH TF9OT19DT05URVhUKTsKKyAgICAgICAgY2xlYXJDdXJyZW50Q29udGV4dCgpOwogICAgICAgICBF R0xfRGVzdHJveUNvbnRleHQobV9kaXNwbGF5T2JqLCBtX2NvbnRleHRPYmopOwotICAgIH0KLQor ICAgIH0gZWxzZQorICAgICAgICBBU1NFUlQoY3VycmVudENvbnRleHQgIT0gdGhpcyk7CiAgICAg TE9HKFdlYkdMLCAiRGVzdHJveWVkIGEgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wgKCVwKS4iLCB0 aGlzKTsKIH0KIApAQCAtNDI3LDE4ICs0MzgsMjggQEAgYm9vbCBHcmFwaGljc0NvbnRleHRHTE9w ZW5HTDo6bWFrZUNvbnRleHRDdXJyZW50KCkKICAgICAvLyBUaGUgZXhjZXB0aW9uIGlzIHRoZSBj YXNlIHdoZW4gdGhlIGNvbnRleHQgaXMgdXNlZCBiZWZvcmUgcmVzaGFwaW5nLgogICAgIGlmICgh bV9kaXNwbGF5QnVmZmVyQmFja2luZyAmJiAhZ2V0SW50ZXJuYWxGcmFtZWJ1ZmZlclNpemUoKS5p c0VtcHR5KCkpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICAvLyBBTkdMRSBoYXMgYW4gZWFy bHkgb3V0IGZvciBjYXNlIHdoZXJlIG5vdGhpbmcgY2hhbmdlcy4gQ2FsbGluZyBNYWtlQ3VycmVu dAotICAgIC8vIGlzIGltcG9ydGFudCB0byBzZXQgdm9sYXRpbGUgcGxhdGZvcm0gY29udGV4dC4g U2VlIEluaXRpYWxpemVFR0xEaXNwbGF5KCkuCisgICAgaWYgKGN1cnJlbnRDb250ZXh0ID09IHRo aXMpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIC8vIENhbGxpbmcgTWFrZUN1cnJlbnQgaXMg aW1wb3J0YW50IHRvIHNldCB2b2xhdGlsZSBwbGF0Zm9ybSBjb250ZXh0LiBTZWUgSW5pdGlhbGl6 ZUVHTERpc3BsYXkoKS4KICAgICBpZiAoIUVHTF9NYWtlQ3VycmVudChtX2Rpc3BsYXlPYmosIEVH TF9OT19TVVJGQUNFLCBFR0xfTk9fU1VSRkFDRSwgbV9jb250ZXh0T2JqKSkKICAgICAgICAgcmV0 dXJuIGZhbHNlOworICAgIGlmIChpc0N1cnJlbnRDb250ZXh0UHJlZGljdGFibGUoKSkKKyAgICAg ICAgY3VycmVudENvbnRleHQgPSB0aGlzOwogICAgIHJldHVybiB0cnVlOwogfQogCit2b2lkIEdy YXBoaWNzQ29udGV4dEdMT3BlbkdMOjpjbGVhckN1cnJlbnRDb250ZXh0KCkKK3sKKyAgICBFR0xC b29sZWFuIHJlc3VsdCA9IEVHTF9NYWtlQ3VycmVudChtX2Rpc3BsYXlPYmosIEVHTF9OT19TVVJG QUNFLCBFR0xfTk9fU1VSRkFDRSwgRUdMX05PX0NPTlRFWFQpOworICAgIEFTU0VSVF9VTlVTRUQo cmVzdWx0LCByZXN1bHQpOworICAgIGN1cnJlbnRDb250ZXh0ID0gbnVsbHB0cjsKK30KKwogI2lm IFBMQVRGT1JNKElPU19GQU1JTFkpCiBib29sIEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpyZWxl YXNlQ3VycmVudENvbnRleHQoUmVsZWFzZUJlaGF2aW9yIHJlbGVhc2VCZWhhdmlvcikKIHsKICAg ICAvLyBBdCB0aGUgbW9tZW50IHRoaXMgZnVuY3Rpb24gaXMgcmVsZXZhbnQgb25seSB3aGVuIHdl YiB0aHJlYWQgbG9jayBvd25zIHRoZSBHcmFwaGljc0NvbnRleHRHTE9wZW5HTCBjdXJyZW50IGNv bnRleHQuCi0gICAgQVNTRVJUKCFXZWJDb3JlOjppc0luV2ViUHJvY2VzcygpKTsKKyAgICBBU1NF UlQoIWlzQ3VycmVudENvbnRleHRQcmVkaWN0YWJsZSgpKTsKIAogICAgIGlmICghRUdMX0JpbmRB UEkoRUdMX09QRU5HTF9FU19BUEkpKQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC00NzYsOSAr NDk3LDcgQEAgdm9pZCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6Y2hlY2tHUFVTdGF0dXMoKQog ICAgICAgICBMT0coV2ViR0wsICJQcmV0ZW5kaW5nIHRoZSBHUFUgaGFzIHJlc2V0ICglcCkuIExv c2UgdGhlIGNvbnRleHQuIiwgdGhpcyk7CiAgICAgICAgIG1fZmFpbE5leHRTdGF0dXNDaGVjayA9 IGZhbHNlOwogICAgICAgICBmb3JjZUNvbnRleHRMb3N0KCk7Ci0KLSAgICAgICAgRUdMX0JpbmRB UEkoRUdMX09QRU5HTF9FU19BUEkpOwotICAgICAgICBFR0xfTWFrZUN1cnJlbnQobV9kaXNwbGF5 T2JqLCBFR0xfTk9fU1VSRkFDRSwgRUdMX05PX1NVUkZBQ0UsIEVHTF9OT19DT05URVhUKTsKKyAg ICAgICAgY2xlYXJDdXJyZW50Q29udGV4dCgpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhp Y3NDb250ZXh0R0xPcGVuR0wuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29w ZW5nbC9HcmFwaGljc0NvbnRleHRHTE9wZW5HTC5oCmluZGV4IDVlMzMwNzc4OWY5MGRiMWE2ZTI3 MWU0YjMyYzQzZDExMTg0YWM2MzkuLmMwOWRlNWJkZjBmN2M3ZjI2ZDNjZDc0MjNjMmVlYzg3NTFj NTJjMjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5n bC9HcmFwaGljc0NvbnRleHRHTE9wZW5HTC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHRHTE9wZW5HTC5oCkBAIC01MzYsNiArNTM2 LDcgQEAgcHJpdmF0ZToKICAgICAvLyBDYWxsZWQgb25jZSBieSBhbGwgdGhlIHB1YmxpYyBlbnRy eSBwb2ludHMgdGhhdCBldmVudHVhbGx5IGNhbGwgT3BlbkdMLgogICAgIC8vIENhbGxlZCBvbmNl IGJ5IGFsbCB0aGUgcHVibGljIGVudHJ5IHBvaW50cyBvZiBFeHRlbnNpb25zR0wgdGhhdCBldmVu dHVhbGx5IGNhbGwgT3BlbkdMLgogICAgIGJvb2wgbWFrZUNvbnRleHRDdXJyZW50KCkgV0FSTl9V TlVTRURfUkVUVVJOOworICAgIHZvaWQgY2xlYXJDdXJyZW50Q29udGV4dCgpOwogCiAgICAgLy8g VGFrZSBpbnRvIGFjY291bnQgdGhlIHVzZXIncyByZXF1ZXN0ZWQgY29udGV4dCBjcmVhdGlvbiBh dHRyaWJ1dGVzLAogICAgIC8vIGluIHBhcnRpY3VsYXIgc3RlbmNpbCBhbmQgYW50aWFsaWFzLCBh bmQgZGV0ZXJtaW5lIHdoaWNoIGNvdWxkIG9yCg==