223033 2021-03-10 10:57:37 -0800 cachedCGColor() and nsColor() are not thread-safe 2021-10-18 13:24:59 -0700 1 1 1 Unclassified WebKit Platform Other Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=220476 https://bugs.webkit.org/show_bug.cgi?id=231909 InRadar P2 Normal --- 1 sam sabouhallawa cdumez darin eric.carlson sabouhallawa simon.fraser webkit-bug-importer wenson_hsieh ysuzuki oldest_to_newest 1738131 0 sam 2021-03-10 10:57:37 -0800 cachedCGColor() is not thread-safe, and will break if used of OffscreenCanvas or multi-queue display list replaying. 1738463 1 webkit-bug-importer 2021-03-11 08:53:08 -0800 <rdar://problem/75317764> 1751286 2 426285 sabouhallawa 2021-04-16 15:32:36 -0700 Created attachment 426285 Patch 1751288 3 426285 cdumez 2021-04-16 15:34:00 -0700 Comment on attachment 426285 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426285&action=review > Source/WebCore/platform/graphics/cg/ColorCG.cpp:145 > + LockHolder lockHolder(&cachedCGColorLock); You static initializations above are not thread-safe either as far as I know. 1751289 4 cdumez 2021-04-16 15:34:15 -0700 (In reply to Chris Dumez from comment #3) > Comment on attachment 426285 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=426285&action=review > > > Source/WebCore/platform/graphics/cg/ColorCG.cpp:145 > > + LockHolder lockHolder(&cachedCGColorLock); > > You static initializations above are not thread-safe either as far as I know. *Your* 1751295 5 426285 ysuzuki 2021-04-16 15:48:53 -0700 Comment on attachment 426285 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426285&action=review >>> Source/WebCore/platform/graphics/cg/ColorCG.cpp:145 >>> + LockHolder lockHolder(&cachedCGColorLock); >> >> You static initializations above are not thread-safe either as far as I know. > > *Your* Is it correct? Lock has constexpr constructor, and compiler initializes the content in __DATA section. 1751297 6 cdumez 2021-04-16 15:50:53 -0700 (In reply to Yusuke Suzuki from comment #5) > Comment on attachment 426285 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=426285&action=review > > >>> Source/WebCore/platform/graphics/cg/ColorCG.cpp:145 > >>> + LockHolder lockHolder(&cachedCGColorLock); > >> > >> You static initializations above are not thread-safe either as far as I know. > > > > *Your* > > Is it correct? Lock has constexpr constructor, and compiler initializes the > content in __DATA section. To clarify, I was talking about these kind of static initialization that happen before your lock, in the same function: ``` static NeverDestroyed<RetainPtr<CGColorRef>> transparentCGColor = createCGColor(color); return transparentCGColor.get().get(); ``` 1751304 7 426285 ysuzuki 2021-04-16 15:58:42 -0700 Comment on attachment 426285 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426285&action=review >>>>> Source/WebCore/platform/graphics/cg/ColorCG.cpp:145 >>>>> + LockHolder lockHolder(&cachedCGColorLock); >>>> >>>> You static initializations above are not thread-safe either as far as I know. >>> >>> *Your* >> >> Is it correct? Lock has constexpr constructor, and compiler initializes the content in __DATA section. > > To clarify, I was talking about these kind of static initialization that happen before your lock, in the same function: > ``` > static NeverDestroyed<RetainPtr<CGColorRef>> transparentCGColor = createCGColor(color); > return transparentCGColor.get().get(); > ``` Right. Using std::call_once & LazyNeverDestroyed<> would be better here. 1751305 8 426288 sabouhallawa 2021-04-16 16:00:58 -0700 Created attachment 426288 Patch 1751312 9 426285 sabouhallawa 2021-04-16 16:08:21 -0700 Comment on attachment 426285 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426285&action=review >>>>>> Source/WebCore/platform/graphics/cg/ColorCG.cpp:145 >>>>>> + LockHolder lockHolder(&cachedCGColorLock); >>>>> >>>>> You static initializations above are not thread-safe either as far as I know. >>>> >>>> *Your* >>> >>> Is it correct? Lock has constexpr constructor, and compiler initializes the content in __DATA section. >> >> To clarify, I was talking about these kind of static initialization that happen before your lock, in the same function: >> ``` >> static NeverDestroyed<RetainPtr<CGColorRef>> transparentCGColor = createCGColor(color); >> return transparentCGColor.get().get(); >> ``` > > Right. Using std::call_once & LazyNeverDestroyed<> would be better here. You are right. The call to createCGColor() in the statement: static NeverDestroyed<RetainPtr<CGColorRef>> transparentCGColor = createCGColor(color); happens only once when this code is first hit. Subsequent calls will use the static cached value 'transparentCGColor'. 1751325 10 cdumez 2021-04-16 17:13:44 -0700 Do we need to perf-test this (MotionMark for e.g.)? Seems like this might be a hot function although I am not familiar with this code. 1751440 11 sam 2021-04-17 11:44:34 -0700 You may also want to do the same for nsColor() in ColorMac.mm, not sure if that is used from a background thread or not, but it unlikely to be hot and has the same problem. 1751441 12 sam 2021-04-17 11:47:30 -0700 It would also be good if we could avoid the lock in the case of the transparent/white/black cases, as those represent a large percentage of the calls (last time I measured). Using std::call_once / LazyNeverDestroyed would allow the lock to be moved below the fast case. 1751443 13 cdumez 2021-04-17 12:01:49 -0700 (In reply to Sam Weinig from comment #12) > It would also be good if we could avoid the lock in the case of the > transparent/white/black cases, as those represent a large percentage of the > calls (last time I measured). > > Using std::call_once / LazyNeverDestroyed would allow the lock to be moved > below the fast case. I Agree. That is also was Yusuke suggested earlier. 1751543 14 426288 darin 2021-04-17 20:52:28 -0700 Comment on attachment 426288 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426288&action=review Is the additional slowness from a lock in this function acceptable? > Source/WebCore/platform/graphics/cg/ColorCG.cpp:128 > + static Lock cachedCGColorLock; > + LockHolder lockHolder(&cachedCGColorLock); I suggest locking *after* the fast path special cases for transparentBlack, black, and white. The lock is not needed for that code. 1751544 15 darin 2021-04-17 20:52:54 -0700 Oh, I see that you already discussed all of this above. 1751545 16 426288 darin 2021-04-17 20:53:44 -0700 Comment on attachment 426288 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426288&action=review >> Source/WebCore/platform/graphics/cg/ColorCG.cpp:128 >> + LockHolder lockHolder(&cachedCGColorLock); > > I suggest locking *after* the fast path special cases for transparentBlack, black, and white. The lock is not needed for that code. I guess I’m wrong about that since we don’t use thread-safe statics. Even those need the locking the way this is currently written. That’s unfortunate and fixable if we needed to fix it. 1751948 17 426288 sabouhallawa 2021-04-19 13:39:58 -0700 Comment on attachment 426288 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426288&action=review >>> Source/WebCore/platform/graphics/cg/ColorCG.cpp:128 >>> + LockHolder lockHolder(&cachedCGColorLock); >> >> I suggest locking *after* the fast path special cases for transparentBlack, black, and white. The lock is not needed for that code. > > I guess I’m wrong about that since we don’t use thread-safe statics. Even those need the locking the way this is currently written. That’s unfortunate and fixable if we needed to fix it. I do not know what "thread-safe statics" means. Also in this page https://en.cppreference.com/w/cpp/thread/call_once, I read this statement "Initialization of function-local statics is guaranteed to occur only once even when called from multiple threads, and may be more efficient than the equivalent code using std::call_once." Does not this mean this statement will be safely executed once? static NeverDestroyed<RetainPtr<CGColorRef>> whiteCGColor = createCGColor(color); 1751949 18 cdumez 2021-04-19 13:41:19 -0700 (In reply to Said Abou-Hallawa from comment #17) > Comment on attachment 426288 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=426288&action=review > > >>> Source/WebCore/platform/graphics/cg/ColorCG.cpp:128 > >>> + LockHolder lockHolder(&cachedCGColorLock); > >> > >> I suggest locking *after* the fast path special cases for transparentBlack, black, and white. The lock is not needed for that code. > > > > I guess I’m wrong about that since we don’t use thread-safe statics. Even those need the locking the way this is currently written. That’s unfortunate and fixable if we needed to fix it. > > I do not know what "thread-safe statics" means. Also in this page > https://en.cppreference.com/w/cpp/thread/call_once, I read this statement > > "Initialization of function-local statics is guaranteed to occur only once > even when called from multiple threads, and may be more efficient than the > equivalent code using std::call_once." > > Does not this mean this statement will be safely executed once? > > static NeverDestroyed<RetainPtr<CGColorRef>> whiteCGColor = > createCGColor(color); No because we compile with -fno-threadsafe-statics for perf reasons. 1751950 19 cdumez 2021-04-19 13:43:38 -0700 (In reply to Chris Dumez from comment #18) > (In reply to Said Abou-Hallawa from comment #17) > > Comment on attachment 426288 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=426288&action=review > > > > >>> Source/WebCore/platform/graphics/cg/ColorCG.cpp:128 > > >>> + LockHolder lockHolder(&cachedCGColorLock); > > >> > > >> I suggest locking *after* the fast path special cases for transparentBlack, black, and white. The lock is not needed for that code. > > > > > > I guess I’m wrong about that since we don’t use thread-safe statics. Even those need the locking the way this is currently written. That’s unfortunate and fixable if we needed to fix it. > > > > I do not know what "thread-safe statics" means. Also in this page > > https://en.cppreference.com/w/cpp/thread/call_once, I read this statement > > > > "Initialization of function-local statics is guaranteed to occur only once > > even when called from multiple threads, and may be more efficient than the > > equivalent code using std::call_once." > > > > Does not this mean this statement will be safely executed once? > > > > static NeverDestroyed<RetainPtr<CGColorRef>> whiteCGColor = > > createCGColor(color); > > No because we compile with -fno-threadsafe-statics for perf reasons. AFAIK, the recommended pattern in WebKit for local statics when multiple threads are involved is LazyNeverDestroyed + std::call_once. 1751975 20 darin 2021-04-19 14:30:33 -0700 (In reply to Said Abou-Hallawa from comment #17) > I do not know what "thread-safe statics" means. C++ normally guarantees that initialization of static local variables <https://en.cppreference.com/w/cpp/language/storage_duration#Static_local_variables> happens exactly once. Compilers like clang refer to that C++ language feature as "thread-safe statics". In the WebKit project we turn that language feature off, putting the compiler into a non-standard mode that is more efficient, by compiling with clang's "-fno-threadsafe-statics", for example. It would be good for us to some day do the performance measurement work to prove that we can move to the standard C++ semantics without a major performance cost. If we could do that, we could then simplify a lot of our C++ code, which does extra work to get the thread safety when we need it. 1752015 21 426482 sabouhallawa 2021-04-19 15:42:50 -0700 Created attachment 426482 Patch 1752018 22 426482 darin 2021-04-19 15:45:21 -0700 Comment on attachment 426482 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426482&action=review What about the NSColor method? > Source/WebCore/platform/graphics/cg/ColorCG.cpp:134 > + std::call_once(onceFlag, [&color] { > + transparentCGColor.construct(createCGColor(color)); > + }); We don’t really need to capture color here. Could write this instead: std::call(onceFlag, [] { transparentCGColor.construct(createCGColor(Color::transparentBlack)); }); > Source/WebCore/platform/graphics/cg/ColorCG.cpp:142 > + std::call_once(onceFlag, [&color] { > + blackCGColor.construct(createCGColor(color)); > + }); Ditto. > Source/WebCore/platform/graphics/cg/ColorCG.cpp:150 > + std::call_once(onceFlag, [&color] { > + whiteCGColor.construct(createCGColor(color)); > + }); Ditto. 1752019 23 426482 darin 2021-04-19 15:46:52 -0700 Comment on attachment 426482 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426482&action=review >> Source/WebCore/platform/graphics/cg/ColorCG.cpp:134 >> + }); > > We don’t really need to capture color here. Could write this instead: > > std::call(onceFlag, [] { > transparentCGColor.construct(createCGColor(Color::transparentBlack)); > }); Wait, we need to capture transparentCGColor. I don’t understand how the code in the patch successfully compiles. 1752020 24 426482 darin 2021-04-19 15:47:56 -0700 Comment on attachment 426482 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426482&action=review > Source/WebCore/platform/graphics/cg/ColorCG.cpp:157 > + LockHolder lockHolder(&cachedCGColorLock); I think the preferred idiom is: auto holder = holdLock(cachedCGColorLock); 1752025 25 426482 cdumez 2021-04-19 15:52:01 -0700 Comment on attachment 426482 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426482&action=review >>> Source/WebCore/platform/graphics/cg/ColorCG.cpp:134 >>> + }); >> >> We don’t really need to capture color here. Could write this instead: >> >> std::call(onceFlag, [] { >> transparentCGColor.construct(createCGColor(Color::transparentBlack)); >> }); > > Wait, we need to capture transparentCGColor. I don’t understand how the code in the patch successfully compiles. AFAIK, you don't need to capture static variables in lambdas. 1752026 26 426482 darin 2021-04-19 15:52:36 -0700 Comment on attachment 426482 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426482&action=review >>>> Source/WebCore/platform/graphics/cg/ColorCG.cpp:134 >>>> + }); >>> >>> We don’t really need to capture color here. Could write this instead: >>> >>> std::call(onceFlag, [] { >>> transparentCGColor.construct(createCGColor(Color::transparentBlack)); >>> }); >> >> Wait, we need to capture transparentCGColor. I don’t understand how the code in the patch successfully compiles. > > AFAIK, you don't need to capture static variables in lambdas. OK, got it! Then my comment stands as-is. 1752064 27 426497 sabouhallawa 2021-04-19 17:34:12 -0700 Created attachment 426497 Patch 1752066 28 426482 sabouhallawa 2021-04-19 17:35:47 -0700 Comment on attachment 426482 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426482&action=review I did similar changes in nsColor(). >>>>> Source/WebCore/platform/graphics/cg/ColorCG.cpp:134 >>>>> + }); >>>> >>>> We don’t really need to capture color here. Could write this instead: >>>> >>>> std::call(onceFlag, [] { >>>> transparentCGColor.construct(createCGColor(Color::transparentBlack)); >>>> }); >>> >>> Wait, we need to capture transparentCGColor. I don’t understand how the code in the patch successfully compiles. >> >> AFAIK, you don't need to capture static variables in lambdas. > > OK, got it! Then my comment stands as-is. Done. >> Source/WebCore/platform/graphics/cg/ColorCG.cpp:157 >> + LockHolder lockHolder(&cachedCGColorLock); > > I think the preferred idiom is: > > auto holder = holdLock(cachedCGColorLock); Done. 1752086 29 426497 cdumez 2021-04-19 18:33:19 -0700 Comment on attachment 426497 Patch Looks correct. I hope this doesn't regress perf though. 1752098 30 426510 sabouhallawa 2021-04-19 19:24:31 -0700 Created attachment 426510 Patch Fix win port 1752130 31 ews-feeder 2021-04-19 21:45:49 -0700 Committed r276283 (236765@main): <https://commits.webkit.org/236765@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 426510. 1805659 32 darin 2021-10-18 11:20:34 -0700 This doesn’t work yet, because the return values are unretained objects that can be released from the cache on any other thread. 1805700 33 cdumez 2021-10-18 13:24:59 -0700 (In reply to Darin Adler from comment #32) > This doesn’t work yet, because the return values are unretained objects that > can be released from the cache on any other thread. Indeed, will follow up via Bug 231909. 426285 2021-04-16 15:32:36 -0700 2021-04-16 16:00:56 -0700 Patch bug-223033-20210416153236.patch text/plain 1624 sabouhallawa U3VidmVyc2lvbiBSZXZpc2lvbjogMjc2MTQ2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2M5ZDBhNWE4MDE2ZjFl MTk1NjA5MWMzNWJhMjMzMmM5YWNmYjk4YS4uZmQ0Yjk4ZGUzNDIxN2U1ZDEwNjQwYzZiOTRhNTcw MDIyM2RkNWVhMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTA0LTE2ICBTYWlk IEFib3UtSGFsbGF3YSAgPHNhaWRAYXBwbGUuY29tPgorCisgICAgICAgIGNhY2hlZENHQ29sb3Io KSBpcyBub3QgdGhyZWFkLXNhZmUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIyMzAzMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIGNhY2hlZENHQ29sb3IoKSB3aWxsIGJyZWFrIHdoZW4gaXQgaXMgdXNlZCBi eSBhbiBPZmZzY3JlZW5DYW52YXMgd2hpY2gKKyAgICAgICAgY3JlYXRlcyBpdHMgSW1hZ2VCdWZm ZXIgYW5kIGRyYXdzIGluIGl0IG9uIGEgd29ya2VyIHRocmVhZC4KKworICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL2NnL0NvbG9yQ0cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y2FjaGVkQ0dD b2xvcik6CisKIDIwMjEtMDQtMTYgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAog ICAgICAgICBVbnJldmlld2VkIGF0dGVtcHQgdG8gZml4IEdUSydzIGJ1aWxkIGFmdGVyIEFudG9p bmUncyByMjc2MTQxLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2cvQ29sb3JDRy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9D b2xvckNHLmNwcAppbmRleCBjNjc0OWQ4M2RjMWZjMTA5NGU4Mzk0N2NmNTBhODU3ZWU0OTRlMzBj Li44YzhmYjQ5OWE1OGUwNmUyNjBkY2I2MTJkNmQ1Yjg3Yjc3ZDUzZmU0IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Db2xvckNHLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Db2xvckNHLmNwcApAQCAtMzAsNiArMzAs NyBAQAogCiAjaW5jbHVkZSAiQ29sb3JTcGFjZUNHLmgiCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlv bnMuaD4KKyNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4K ICNpbmNsdWRlIDx3dGYvVGlueUxSVUNhY2hlLmg+CiAjaW5jbHVkZSA8cGFsL3NwaS9jZy9Db3Jl R3JhcGhpY3NTUEkuaD4KQEAgLTE0MCw2ICsxNDEsOSBAQCBDR0NvbG9yUmVmIGNhY2hlZENHQ29s b3IoY29uc3QgQ29sb3ImIGNvbG9yKQogICAgICAgICB9CiAgICAgfQogCisgICAgc3RhdGljIExv Y2sgY2FjaGVkQ0dDb2xvckxvY2s7CisgICAgTG9ja0hvbGRlciBsb2NrSG9sZGVyKCZjYWNoZWRD R0NvbG9yTG9jayk7CisKICAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8VGlueUxSVUNhY2hlPENv bG9yLCBSZXRhaW5QdHI8Q0dDb2xvclJlZj4sIDMyPj4gY2FjaGU7CiAgICAgcmV0dXJuIGNhY2hl LmdldCgpLmdldChjb2xvcikuZ2V0KCk7CiB9Cg== 426288 2021-04-16 16:00:58 -0700 2021-04-19 17:34:06 -0700 Patch bug-223033-20210416160057.patch text/plain 1720 sabouhallawa U3VidmVyc2lvbiBSZXZpc2lvbjogMjc2MTQ2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2M5ZDBhNWE4MDE2ZjFl MTk1NjA5MWMzNWJhMjMzMmM5YWNmYjk4YS4uZmQ0Yjk4ZGUzNDIxN2U1ZDEwNjQwYzZiOTRhNTcw MDIyM2RkNWVhMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTA0LTE2ICBTYWlk IEFib3UtSGFsbGF3YSAgPHNhaWRAYXBwbGUuY29tPgorCisgICAgICAgIGNhY2hlZENHQ29sb3Io KSBpcyBub3QgdGhyZWFkLXNhZmUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIyMzAzMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIGNhY2hlZENHQ29sb3IoKSB3aWxsIGJyZWFrIHdoZW4gaXQgaXMgdXNlZCBi eSBhbiBPZmZzY3JlZW5DYW52YXMgd2hpY2gKKyAgICAgICAgY3JlYXRlcyBpdHMgSW1hZ2VCdWZm ZXIgYW5kIGRyYXdzIGluIGl0IG9uIGEgd29ya2VyIHRocmVhZC4KKworICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL2NnL0NvbG9yQ0cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y2FjaGVkQ0dD b2xvcik6CisKIDIwMjEtMDQtMTYgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAog ICAgICAgICBVbnJldmlld2VkIGF0dGVtcHQgdG8gZml4IEdUSydzIGJ1aWxkIGFmdGVyIEFudG9p bmUncyByMjc2MTQxLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2cvQ29sb3JDRy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9D b2xvckNHLmNwcAppbmRleCBjNjc0OWQ4M2RjMWZjMTA5NGU4Mzk0N2NmNTBhODU3ZWU0OTRlMzBj Li4xNWZjYmMzZDlkMjRkYWI2ZmM4YzJkNjVjYmM1ODliMDk4OWE3YWIyIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Db2xvckNHLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Db2xvckNHLmNwcApAQCAtMzAsNiArMzAs NyBAQAogCiAjaW5jbHVkZSAiQ29sb3JTcGFjZUNHLmgiCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlv bnMuaD4KKyNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4K ICNpbmNsdWRlIDx3dGYvVGlueUxSVUNhY2hlLmg+CiAjaW5jbHVkZSA8cGFsL3NwaS9jZy9Db3Jl R3JhcGhpY3NTUEkuaD4KQEAgLTEyMyw2ICsxMjQsOSBAQCBzdGF0aWMgUmV0YWluUHRyPENHQ29s b3JSZWY+IGNyZWF0ZUNHQ29sb3IoY29uc3QgQ29sb3ImIGNvbG9yKQogCiBDR0NvbG9yUmVmIGNh Y2hlZENHQ29sb3IoY29uc3QgQ29sb3ImIGNvbG9yKQogeworICAgIHN0YXRpYyBMb2NrIGNhY2hl ZENHQ29sb3JMb2NrOworICAgIExvY2tIb2xkZXIgbG9ja0hvbGRlcigmY2FjaGVkQ0dDb2xvckxv Y2spOworCiAgICAgaWYgKGF1dG8gc3JnYiA9IGNvbG9yLnRyeUdldEFzU1JHQkFCeXRlcygpKSB7 CiAgICAgICAgIHN3aXRjaCAoUGFja2VkQ29sb3I6OlJHQkEgeyAqc3JnYiB9LnZhbHVlKSB7CiAg ICAgICAgIGNhc2UgUGFja2VkQ29sb3I6OlJHQkEgeyBDb2xvcjo6dHJhbnNwYXJlbnRCbGFjayB9 LnZhbHVlOiB7Cg== 426482 2021-04-19 15:42:50 -0700 2021-04-19 18:09:54 -0700 Patch bug-223033-20210419154250.patch text/plain 3146 sabouhallawa U3VidmVyc2lvbiBSZXZpc2lvbjogMjc2MTQ2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2M5ZDBhNWE4MDE2ZjFl MTk1NjA5MWMzNWJhMjMzMmM5YWNmYjk4YS4uZmQ0Yjk4ZGUzNDIxN2U1ZDEwNjQwYzZiOTRhNTcw MDIyM2RkNWVhMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTA0LTE2ICBTYWlk IEFib3UtSGFsbGF3YSAgPHNhaWRAYXBwbGUuY29tPgorCisgICAgICAgIGNhY2hlZENHQ29sb3Io KSBpcyBub3QgdGhyZWFkLXNhZmUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIyMzAzMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIGNhY2hlZENHQ29sb3IoKSB3aWxsIGJyZWFrIHdoZW4gaXQgaXMgdXNlZCBi eSBhbiBPZmZzY3JlZW5DYW52YXMgd2hpY2gKKyAgICAgICAgY3JlYXRlcyBpdHMgSW1hZ2VCdWZm ZXIgYW5kIGRyYXdzIGluIGl0IG9uIGEgd29ya2VyIHRocmVhZC4KKworICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL2NnL0NvbG9yQ0cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y2FjaGVkQ0dD b2xvcik6CisKIDIwMjEtMDQtMTYgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAog ICAgICAgICBVbnJldmlld2VkIGF0dGVtcHQgdG8gZml4IEdUSydzIGJ1aWxkIGFmdGVyIEFudG9p bmUncyByMjc2MTQxLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2cvQ29sb3JDRy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9D b2xvckNHLmNwcAppbmRleCBjNjc0OWQ4M2RjMWZjMTA5NGU4Mzk0N2NmNTBhODU3ZWU0OTRlMzBj Li4yZTNiMTcyNTgwNDUzNzNkMWFhZGM5MmQ5YmY0NTJlNmRjMjQ5MzEwIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Db2xvckNHLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Db2xvckNHLmNwcApAQCAtMzAsNiArMzAs NyBAQAogCiAjaW5jbHVkZSAiQ29sb3JTcGFjZUNHLmgiCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlv bnMuaD4KKyNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4K ICNpbmNsdWRlIDx3dGYvVGlueUxSVUNhY2hlLmg+CiAjaW5jbHVkZSA8cGFsL3NwaS9jZy9Db3Jl R3JhcGhpY3NTUEkuaD4KQEAgLTEyNiwyMCArMTI3LDM1IEBAIENHQ29sb3JSZWYgY2FjaGVkQ0dD b2xvcihjb25zdCBDb2xvciYgY29sb3IpCiAgICAgaWYgKGF1dG8gc3JnYiA9IGNvbG9yLnRyeUdl dEFzU1JHQkFCeXRlcygpKSB7CiAgICAgICAgIHN3aXRjaCAoUGFja2VkQ29sb3I6OlJHQkEgeyAq c3JnYiB9LnZhbHVlKSB7CiAgICAgICAgIGNhc2UgUGFja2VkQ29sb3I6OlJHQkEgeyBDb2xvcjo6 dHJhbnNwYXJlbnRCbGFjayB9LnZhbHVlOiB7Ci0gICAgICAgICAgICBzdGF0aWMgTmV2ZXJEZXN0 cm95ZWQ8UmV0YWluUHRyPENHQ29sb3JSZWY+PiB0cmFuc3BhcmVudENHQ29sb3IgPSBjcmVhdGVD R0NvbG9yKGNvbG9yKTsKKyAgICAgICAgICAgIHN0YXRpYyBMYXp5TmV2ZXJEZXN0cm95ZWQ8UmV0 YWluUHRyPENHQ29sb3JSZWY+PiB0cmFuc3BhcmVudENHQ29sb3I7CisgICAgICAgICAgICBzdGF0 aWMgc3RkOjpvbmNlX2ZsYWcgb25jZUZsYWc7CisgICAgICAgICAgICBzdGQ6OmNhbGxfb25jZShv bmNlRmxhZywgWyZjb2xvcl0geworICAgICAgICAgICAgICAgIHRyYW5zcGFyZW50Q0dDb2xvci5j b25zdHJ1Y3QoY3JlYXRlQ0dDb2xvcihjb2xvcikpOworICAgICAgICAgICAgfSk7CiAgICAgICAg ICAgICByZXR1cm4gdHJhbnNwYXJlbnRDR0NvbG9yLmdldCgpLmdldCgpOwogICAgICAgICB9CiAg ICAgICAgIGNhc2UgUGFja2VkQ29sb3I6OlJHQkEgeyBDb2xvcjo6YmxhY2sgfS52YWx1ZTogewot ICAgICAgICAgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPFJldGFpblB0cjxDR0NvbG9yUmVmPj4g YmxhY2tDR0NvbG9yID0gY3JlYXRlQ0dDb2xvcihjb2xvcik7CisgICAgICAgICAgICBzdGF0aWMg TGF6eU5ldmVyRGVzdHJveWVkPFJldGFpblB0cjxDR0NvbG9yUmVmPj4gYmxhY2tDR0NvbG9yOwor ICAgICAgICAgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIG9uY2VGbGFnOworICAgICAgICAgICAg c3RkOjpjYWxsX29uY2Uob25jZUZsYWcsIFsmY29sb3JdIHsKKyAgICAgICAgICAgICAgICBibGFj a0NHQ29sb3IuY29uc3RydWN0KGNyZWF0ZUNHQ29sb3IoY29sb3IpKTsKKyAgICAgICAgICAgIH0p OwogICAgICAgICAgICAgcmV0dXJuIGJsYWNrQ0dDb2xvci5nZXQoKS5nZXQoKTsKICAgICAgICAg fQogICAgICAgICBjYXNlIFBhY2tlZENvbG9yOjpSR0JBIHsgQ29sb3I6OndoaXRlIH0udmFsdWU6 IHsKLSAgICAgICAgICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxSZXRhaW5QdHI8Q0dDb2xvclJl Zj4+IHdoaXRlQ0dDb2xvciA9IGNyZWF0ZUNHQ29sb3IoY29sb3IpOworICAgICAgICAgICAgc3Rh dGljIExhenlOZXZlckRlc3Ryb3llZDxSZXRhaW5QdHI8Q0dDb2xvclJlZj4+IHdoaXRlQ0dDb2xv cjsKKyAgICAgICAgICAgIHN0YXRpYyBzdGQ6Om9uY2VfZmxhZyBvbmNlRmxhZzsKKyAgICAgICAg ICAgIHN0ZDo6Y2FsbF9vbmNlKG9uY2VGbGFnLCBbJmNvbG9yXSB7CisgICAgICAgICAgICAgICAg d2hpdGVDR0NvbG9yLmNvbnN0cnVjdChjcmVhdGVDR0NvbG9yKGNvbG9yKSk7CisgICAgICAgICAg ICB9KTsKICAgICAgICAgICAgIHJldHVybiB3aGl0ZUNHQ29sb3IuZ2V0KCkuZ2V0KCk7CiAgICAg ICAgIH0KICAgICAgICAgfQogICAgIH0KIAorICAgIHN0YXRpYyBMb2NrIGNhY2hlZENHQ29sb3JM b2NrOworICAgIExvY2tIb2xkZXIgbG9ja0hvbGRlcigmY2FjaGVkQ0dDb2xvckxvY2spOworCiAg ICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPFRpbnlMUlVDYWNoZTxDb2xvciwgUmV0YWluUHRyPENH Q29sb3JSZWY+LCAzMj4+IGNhY2hlOwogICAgIHJldHVybiBjYWNoZS5nZXQoKS5nZXQoY29sb3Ip LmdldCgpOwogfQo= 426497 2021-04-19 17:34:12 -0700 2021-04-19 19:28:35 -0700 Patch bug-223033-20210419173411.patch text/plain 5603 sabouhallawa U3VidmVyc2lvbiBSZXZpc2lvbjogMjc2MTQ2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2M5ZDBhNWE4MDE2ZjFl MTk1NjA5MWMzNWJhMjMzMmM5YWNmYjk4YS4uODBiZmFiZGNkOGI2NGM1NWI0ZjUxMmMzNjI2YzM2 MzNiMGJiNTAzMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIxLTA0LTE5ICBTYWlk IEFib3UtSGFsbGF3YSAgPHNhaWRAYXBwbGUuY29tPgorCisgICAgICAgIGNhY2hlZENHQ29sb3Io KSBhbmQgbnNDb2xvcigpIGFyZSBub3QgdGhyZWFkLXNhZmUKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyMzAzMworCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZXNlIGZ1bmN0aW9ucyB3aWxsIGJyZWFrIGlm IHRoZXkgYXJlIHVzZWQgYnkgd29ya2VyIHRocmVhZC4KKworICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2NnL0NvbG9yQ0cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y2FjaGVkQ0dDb2xvcik6 CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvbWFjL0NvbG9yTWFjLm1tOgorICAgICAgICAo V2ViQ29yZTo6bnNDb2xvcik6CisKIDIwMjEtMDQtMTYgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFw cGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkIGF0dGVtcHQgdG8gZml4IEdUSydzIGJ1aWxk IGFmdGVyIEFudG9pbmUncyByMjc2MTQxLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2cvQ29sb3JDRy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jZy9Db2xvckNHLmNwcAppbmRleCBjNjc0OWQ4M2RjMWZjMTA5NGU4Mzk0N2NmNTBh ODU3ZWU0OTRlMzBjLi5lZDlhNTg2ZjI3YzJmMzcyNWUyNjljOWQzZWUzNGNiNzI1OGY0YzkxIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Db2xvckNHLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Db2xvckNHLmNwcApA QCAtMzAsNiArMzAsNyBAQAogCiAjaW5jbHVkZSAiQ29sb3JTcGFjZUNHLmgiCiAjaW5jbHVkZSA8 d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9S ZXRhaW5QdHIuaD4KICNpbmNsdWRlIDx3dGYvVGlueUxSVUNhY2hlLmg+CiAjaW5jbHVkZSA8cGFs L3NwaS9jZy9Db3JlR3JhcGhpY3NTUEkuaD4KQEAgLTEyNiwyMCArMTI3LDM1IEBAIENHQ29sb3JS ZWYgY2FjaGVkQ0dDb2xvcihjb25zdCBDb2xvciYgY29sb3IpCiAgICAgaWYgKGF1dG8gc3JnYiA9 IGNvbG9yLnRyeUdldEFzU1JHQkFCeXRlcygpKSB7CiAgICAgICAgIHN3aXRjaCAoUGFja2VkQ29s b3I6OlJHQkEgeyAqc3JnYiB9LnZhbHVlKSB7CiAgICAgICAgIGNhc2UgUGFja2VkQ29sb3I6OlJH QkEgeyBDb2xvcjo6dHJhbnNwYXJlbnRCbGFjayB9LnZhbHVlOiB7Ci0gICAgICAgICAgICBzdGF0 aWMgTmV2ZXJEZXN0cm95ZWQ8UmV0YWluUHRyPENHQ29sb3JSZWY+PiB0cmFuc3BhcmVudENHQ29s b3IgPSBjcmVhdGVDR0NvbG9yKGNvbG9yKTsKKyAgICAgICAgICAgIHN0YXRpYyBMYXp5TmV2ZXJE ZXN0cm95ZWQ8UmV0YWluUHRyPENHQ29sb3JSZWY+PiB0cmFuc3BhcmVudENHQ29sb3I7CisgICAg ICAgICAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25jZUZsYWc7CisgICAgICAgICAgICBzdGQ6 OmNhbGxfb25jZShvbmNlRmxhZywgW10geworICAgICAgICAgICAgICAgIHRyYW5zcGFyZW50Q0dD b2xvci5jb25zdHJ1Y3QoY3JlYXRlQ0dDb2xvcihDb2xvcjo6dHJhbnNwYXJlbnRCbGFjaykpOwor ICAgICAgICAgICAgfSk7CiAgICAgICAgICAgICByZXR1cm4gdHJhbnNwYXJlbnRDR0NvbG9yLmdl dCgpLmdldCgpOwogICAgICAgICB9CiAgICAgICAgIGNhc2UgUGFja2VkQ29sb3I6OlJHQkEgeyBD b2xvcjo6YmxhY2sgfS52YWx1ZTogewotICAgICAgICAgICAgc3RhdGljIE5ldmVyRGVzdHJveWVk PFJldGFpblB0cjxDR0NvbG9yUmVmPj4gYmxhY2tDR0NvbG9yID0gY3JlYXRlQ0dDb2xvcihjb2xv cik7CisgICAgICAgICAgICBzdGF0aWMgTGF6eU5ldmVyRGVzdHJveWVkPFJldGFpblB0cjxDR0Nv bG9yUmVmPj4gYmxhY2tDR0NvbG9yOworICAgICAgICAgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFn IG9uY2VGbGFnOworICAgICAgICAgICAgc3RkOjpjYWxsX29uY2Uob25jZUZsYWcsIFtdIHsKKyAg ICAgICAgICAgICAgICBibGFja0NHQ29sb3IuY29uc3RydWN0KGNyZWF0ZUNHQ29sb3IoQ29sb3I6 OmJsYWNrKSk7CisgICAgICAgICAgICB9KTsKICAgICAgICAgICAgIHJldHVybiBibGFja0NHQ29s b3IuZ2V0KCkuZ2V0KCk7CiAgICAgICAgIH0KICAgICAgICAgY2FzZSBQYWNrZWRDb2xvcjo6UkdC QSB7IENvbG9yOjp3aGl0ZSB9LnZhbHVlOiB7Ci0gICAgICAgICAgICBzdGF0aWMgTmV2ZXJEZXN0 cm95ZWQ8UmV0YWluUHRyPENHQ29sb3JSZWY+PiB3aGl0ZUNHQ29sb3IgPSBjcmVhdGVDR0NvbG9y KGNvbG9yKTsKKyAgICAgICAgICAgIHN0YXRpYyBMYXp5TmV2ZXJEZXN0cm95ZWQ8UmV0YWluUHRy PENHQ29sb3JSZWY+PiB3aGl0ZUNHQ29sb3I7CisgICAgICAgICAgICBzdGF0aWMgc3RkOjpvbmNl X2ZsYWcgb25jZUZsYWc7CisgICAgICAgICAgICBzdGQ6OmNhbGxfb25jZShvbmNlRmxhZywgW10g eworICAgICAgICAgICAgICAgIHdoaXRlQ0dDb2xvci5jb25zdHJ1Y3QoY3JlYXRlQ0dDb2xvcihD b2xvcjo6d2hpdGUpKTsKKyAgICAgICAgICAgIH0pOwogICAgICAgICAgICAgcmV0dXJuIHdoaXRl Q0dDb2xvci5nZXQoKS5nZXQoKTsKICAgICAgICAgfQogICAgICAgICB9CiAgICAgfQogCisgICAg c3RhdGljIExvY2sgY2FjaGVkQ29sb3JMb2NrOworICAgIGF1dG8gaG9sZGVyID0gaG9sZExvY2so Y2FjaGVkQ29sb3JMb2NrKTsKKwogICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxUaW55TFJVQ2Fj aGU8Q29sb3IsIFJldGFpblB0cjxDR0NvbG9yUmVmPiwgMzI+PiBjYWNoZTsKICAgICByZXR1cm4g Y2FjaGUuZ2V0KCkuZ2V0KGNvbG9yKS5nZXQoKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL21hYy9Db2xvck1hYy5tbSBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL21hYy9Db2xvck1hYy5tbQppbmRleCA2ZGJiZWMyMGQwODM2OWUzYWM2 Mjc1MGQyNGQ2OTFlMjBkYWViMzNjLi41NzdiMDA3NjEzYzMzMTE0MDNkOWE0NzA0NDc0NzEwMzhl Yzc2NDUzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9tYWMv Q29sb3JNYWMubW0KKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvbWFjL0Nv bG9yTWFjLm1tCkBAIC0zMCw2ICszMCw3IEBACiAKICNpbXBvcnQgIkxvY2FsQ3VycmVudEdyYXBo aWNzQ29udGV4dC5oIgogI2ltcG9ydCA8d3RmL0Jsb2NrT2JqQ0V4Y2VwdGlvbnMuaD4KKyNpbXBv cnQgPHd0Zi9Mb2NrLmg+CiAjaW1wb3J0IDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KICNpbXBvcnQg PHd0Zi9SZXRhaW5QdHIuaD4KICNpbXBvcnQgPHd0Zi9UaW55TFJVQ2FjaGUuaD4KQEAgLTExNiwy MCArMTE3LDM1IEBAIE5TQ29sb3IgKm5zQ29sb3IoY29uc3QgQ29sb3ImIGNvbG9yKQogICAgIGlm IChhdXRvIHNyZ2IgPSBjb2xvci50cnlHZXRBc1NSR0JBQnl0ZXMoKSkgewogICAgICAgICBzd2l0 Y2ggKFBhY2tlZENvbG9yOjpSR0JBIHsgKnNyZ2IgfS52YWx1ZSkgewogICAgICAgICBjYXNlIFBh Y2tlZENvbG9yOjpSR0JBIHsgQ29sb3I6OnRyYW5zcGFyZW50QmxhY2sgfS52YWx1ZTogewotICAg ICAgICAgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPFJldGFpblB0cjxOU0NvbG9yPj4gY2xlYXJD b2xvciA9IFtOU0NvbG9yIGNvbG9yV2l0aFNSR0JSZWQ6MCBncmVlbjowIGJsdWU6MCBhbHBoYTow XTsKKyAgICAgICAgICAgIHN0YXRpYyBMYXp5TmV2ZXJEZXN0cm95ZWQ8UmV0YWluUHRyPE5TQ29s b3I+PiBjbGVhckNvbG9yOworICAgICAgICAgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIG9uY2VG bGFnOworICAgICAgICAgICAgc3RkOjpjYWxsX29uY2Uob25jZUZsYWcsIFtdIHsKKyAgICAgICAg ICAgICAgICBjbGVhckNvbG9yLmNvbnN0cnVjdChbTlNDb2xvciBjb2xvcldpdGhTUkdCUmVkOjAg Z3JlZW46MCBibHVlOjAgYWxwaGE6MF0pOworICAgICAgICAgICAgfSk7CiAgICAgICAgICAgICBy ZXR1cm4gY2xlYXJDb2xvci5nZXQoKS5nZXQoKTsKICAgICAgICAgfQogICAgICAgICBjYXNlIFBh Y2tlZENvbG9yOjpSR0JBIHsgQ29sb3I6OmJsYWNrIH0udmFsdWU6IHsKLSAgICAgICAgICAgIHN0 YXRpYyBOZXZlckRlc3Ryb3llZDxSZXRhaW5QdHI8TlNDb2xvcj4+IGJsYWNrQ29sb3IgPSBbTlND b2xvciBjb2xvcldpdGhTUkdCUmVkOjAgZ3JlZW46MCBibHVlOjAgYWxwaGE6MV07CisgICAgICAg ICAgICBzdGF0aWMgTGF6eU5ldmVyRGVzdHJveWVkPFJldGFpblB0cjxOU0NvbG9yPj4gYmxhY2tD b2xvcjsKKyAgICAgICAgICAgIHN0YXRpYyBzdGQ6Om9uY2VfZmxhZyBvbmNlRmxhZzsKKyAgICAg ICAgICAgIHN0ZDo6Y2FsbF9vbmNlKG9uY2VGbGFnLCBbXSB7CisgICAgICAgICAgICAgICAgYmxh Y2tDb2xvci5jb25zdHJ1Y3QoW05TQ29sb3IgY29sb3JXaXRoU1JHQlJlZDowIGdyZWVuOjAgYmx1 ZTowIGFscGhhOjFdKTsKKyAgICAgICAgICAgIH0pOwogICAgICAgICAgICAgcmV0dXJuIGJsYWNr Q29sb3IuZ2V0KCkuZ2V0KCk7CiAgICAgICAgIH0KICAgICAgICAgY2FzZSBQYWNrZWRDb2xvcjo6 UkdCQSB7IENvbG9yOjp3aGl0ZSB9LnZhbHVlOiB7Ci0gICAgICAgICAgICBzdGF0aWMgTmV2ZXJE ZXN0cm95ZWQ8UmV0YWluUHRyPE5TQ29sb3I+PiB3aGl0ZUNvbG9yID0gW05TQ29sb3IgY29sb3JX aXRoU1JHQlJlZDoxIGdyZWVuOjEgYmx1ZToxIGFscGhhOjFdOworICAgICAgICAgICAgc3RhdGlj IExhenlOZXZlckRlc3Ryb3llZDxSZXRhaW5QdHI8TlNDb2xvcj4+IHdoaXRlQ29sb3I7CisgICAg ICAgICAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25jZUZsYWc7CisgICAgICAgICAgICBzdGQ6 OmNhbGxfb25jZShvbmNlRmxhZywgW10geworICAgICAgICAgICAgICAgIHdoaXRlQ29sb3IuY29u c3RydWN0KFtOU0NvbG9yIGNvbG9yV2l0aFNSR0JSZWQ6MSBncmVlbjoxIGJsdWU6MSBhbHBoYTox XSk7CisgICAgICAgICAgICB9KTsKICAgICAgICAgICAgIHJldHVybiB3aGl0ZUNvbG9yLmdldCgp LmdldCgpOwogICAgICAgICB9CiAgICAgICAgIH0KICAgICB9CiAKKyAgICBzdGF0aWMgTG9jayBj YWNoZWRDb2xvckxvY2s7CisgICAgYXV0byBob2xkZXIgPSBob2xkTG9jayhjYWNoZWRDb2xvckxv Y2spOworCiAgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPFRpbnlMUlVDYWNoZTxDb2xvciwgUmV0 YWluUHRyPE5TQ29sb3I+LCAzMj4+IGNhY2hlOwogICAgIHJldHVybiBjYWNoZS5nZXQoKS5nZXQo Y29sb3IpLmdldCgpOwogfQo= 426510 2021-04-19 19:24:31 -0700 2021-04-19 21:45:50 -0700 Patch bug-223033-20210419192430.patch text/plain 5633 sabouhallawa U3VidmVyc2lvbiBSZXZpc2lvbjogMjc2MTQ2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2M5ZDBhNWE4MDE2ZjFl MTk1NjA5MWMzNWJhMjMzMmM5YWNmYjk4YS4uYWZjMzJkODVlNDA2NWE0NThhNTFkNDFkNjZjYzg0 MzNhMTBhZDE1NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIxLTA0LTE5ICBTYWlk IEFib3UtSGFsbGF3YSAgPHNhaWRAYXBwbGUuY29tPgorCisgICAgICAgIGNhY2hlZENHQ29sb3Io KSBhbmQgbnNDb2xvcigpIGFyZSBub3QgdGhyZWFkLXNhZmUKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyMzAzMworCisgICAgICAgIFJldmlld2VkIGJ5 IENocmlzIER1bWV6LgorCisgICAgICAgIFRoZXNlIGZ1bmN0aW9ucyB3aWxsIGJyZWFrIGlmIHRo ZXkgYXJlIHVzZWQgYnkgYSB3b3JrZXIgdGhyZWFkLgorCisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvY2cvQ29sb3JDRy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpjYWNoZWRDR0NvbG9yKToK KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9tYWMvQ29sb3JNYWMubW06CisgICAgICAgIChX ZWJDb3JlOjpuc0NvbG9yKToKKwogMjAyMS0wNC0xNiAgQ2hyaXMgRHVtZXogIDxjZHVtZXpAYXBw bGUuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQgYXR0ZW1wdCB0byBmaXggR1RLJ3MgYnVpbGQg YWZ0ZXIgQW50b2luZSdzIHIyNzYxNDEuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jZy9Db2xvckNHLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2NnL0NvbG9yQ0cuY3BwCmluZGV4IGM2NzQ5ZDgzZGMxZmMxMDk0ZTgzOTQ3Y2Y1MGE4 NTdlZTQ5NGUzMGMuLjY4MDRmMDY5YjUxNDIxMjgzYzlkZDAwZmE5MmNlOGZiYzc5MTZhM2QgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL0NvbG9yQ0cuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL0NvbG9yQ0cuY3BwCkBA IC0yOSw3ICsyOSw5IEBACiAjaWYgVVNFKENHKQogCiAjaW5jbHVkZSAiQ29sb3JTcGFjZUNHLmgi CisjaW5jbHVkZSA8bXV0ZXg+CiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRl IDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9SZXRhaW5QdHIuaD4KICNpbmNsdWRlIDx3dGYv VGlueUxSVUNhY2hlLmg+CiAjaW5jbHVkZSA8cGFsL3NwaS9jZy9Db3JlR3JhcGhpY3NTUEkuaD4K QEAgLTEyNiwyMCArMTI4LDM1IEBAIENHQ29sb3JSZWYgY2FjaGVkQ0dDb2xvcihjb25zdCBDb2xv ciYgY29sb3IpCiAgICAgaWYgKGF1dG8gc3JnYiA9IGNvbG9yLnRyeUdldEFzU1JHQkFCeXRlcygp KSB7CiAgICAgICAgIHN3aXRjaCAoUGFja2VkQ29sb3I6OlJHQkEgeyAqc3JnYiB9LnZhbHVlKSB7 CiAgICAgICAgIGNhc2UgUGFja2VkQ29sb3I6OlJHQkEgeyBDb2xvcjo6dHJhbnNwYXJlbnRCbGFj ayB9LnZhbHVlOiB7Ci0gICAgICAgICAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8UmV0YWluUHRy PENHQ29sb3JSZWY+PiB0cmFuc3BhcmVudENHQ29sb3IgPSBjcmVhdGVDR0NvbG9yKGNvbG9yKTsK KyAgICAgICAgICAgIHN0YXRpYyBMYXp5TmV2ZXJEZXN0cm95ZWQ8UmV0YWluUHRyPENHQ29sb3JS ZWY+PiB0cmFuc3BhcmVudENHQ29sb3I7CisgICAgICAgICAgICBzdGF0aWMgc3RkOjpvbmNlX2Zs YWcgb25jZUZsYWc7CisgICAgICAgICAgICBzdGQ6OmNhbGxfb25jZShvbmNlRmxhZywgW10gewor ICAgICAgICAgICAgICAgIHRyYW5zcGFyZW50Q0dDb2xvci5jb25zdHJ1Y3QoY3JlYXRlQ0dDb2xv cihDb2xvcjo6dHJhbnNwYXJlbnRCbGFjaykpOworICAgICAgICAgICAgfSk7CiAgICAgICAgICAg ICByZXR1cm4gdHJhbnNwYXJlbnRDR0NvbG9yLmdldCgpLmdldCgpOwogICAgICAgICB9CiAgICAg ICAgIGNhc2UgUGFja2VkQ29sb3I6OlJHQkEgeyBDb2xvcjo6YmxhY2sgfS52YWx1ZTogewotICAg ICAgICAgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPFJldGFpblB0cjxDR0NvbG9yUmVmPj4gYmxh Y2tDR0NvbG9yID0gY3JlYXRlQ0dDb2xvcihjb2xvcik7CisgICAgICAgICAgICBzdGF0aWMgTGF6 eU5ldmVyRGVzdHJveWVkPFJldGFpblB0cjxDR0NvbG9yUmVmPj4gYmxhY2tDR0NvbG9yOworICAg ICAgICAgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIG9uY2VGbGFnOworICAgICAgICAgICAgc3Rk OjpjYWxsX29uY2Uob25jZUZsYWcsIFtdIHsKKyAgICAgICAgICAgICAgICBibGFja0NHQ29sb3Iu Y29uc3RydWN0KGNyZWF0ZUNHQ29sb3IoQ29sb3I6OmJsYWNrKSk7CisgICAgICAgICAgICB9KTsK ICAgICAgICAgICAgIHJldHVybiBibGFja0NHQ29sb3IuZ2V0KCkuZ2V0KCk7CiAgICAgICAgIH0K ICAgICAgICAgY2FzZSBQYWNrZWRDb2xvcjo6UkdCQSB7IENvbG9yOjp3aGl0ZSB9LnZhbHVlOiB7 Ci0gICAgICAgICAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8UmV0YWluUHRyPENHQ29sb3JSZWY+ PiB3aGl0ZUNHQ29sb3IgPSBjcmVhdGVDR0NvbG9yKGNvbG9yKTsKKyAgICAgICAgICAgIHN0YXRp YyBMYXp5TmV2ZXJEZXN0cm95ZWQ8UmV0YWluUHRyPENHQ29sb3JSZWY+PiB3aGl0ZUNHQ29sb3I7 CisgICAgICAgICAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25jZUZsYWc7CisgICAgICAgICAg ICBzdGQ6OmNhbGxfb25jZShvbmNlRmxhZywgW10geworICAgICAgICAgICAgICAgIHdoaXRlQ0dD b2xvci5jb25zdHJ1Y3QoY3JlYXRlQ0dDb2xvcihDb2xvcjo6d2hpdGUpKTsKKyAgICAgICAgICAg IH0pOwogICAgICAgICAgICAgcmV0dXJuIHdoaXRlQ0dDb2xvci5nZXQoKS5nZXQoKTsKICAgICAg ICAgfQogICAgICAgICB9CiAgICAgfQogCisgICAgc3RhdGljIExvY2sgY2FjaGVkQ29sb3JMb2Nr OworICAgIGF1dG8gaG9sZGVyID0gaG9sZExvY2soY2FjaGVkQ29sb3JMb2NrKTsKKwogICAgIHN0 YXRpYyBOZXZlckRlc3Ryb3llZDxUaW55TFJVQ2FjaGU8Q29sb3IsIFJldGFpblB0cjxDR0NvbG9y UmVmPiwgMzI+PiBjYWNoZTsKICAgICByZXR1cm4gY2FjaGUuZ2V0KCkuZ2V0KGNvbG9yKS5nZXQo KTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL21hYy9D b2xvck1hYy5tbSBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL21hYy9Db2xvck1h Yy5tbQppbmRleCA2ZGJiZWMyMGQwODM2OWUzYWM2Mjc1MGQyNGQ2OTFlMjBkYWViMzNjLi41Nzdi MDA3NjEzYzMzMTE0MDNkOWE0NzA0NDc0NzEwMzhlYzc2NDUzIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9tYWMvQ29sb3JNYWMubW0KKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvbWFjL0NvbG9yTWFjLm1tCkBAIC0zMCw2ICszMCw3IEBA CiAKICNpbXBvcnQgIkxvY2FsQ3VycmVudEdyYXBoaWNzQ29udGV4dC5oIgogI2ltcG9ydCA8d3Rm L0Jsb2NrT2JqQ0V4Y2VwdGlvbnMuaD4KKyNpbXBvcnQgPHd0Zi9Mb2NrLmg+CiAjaW1wb3J0IDx3 dGYvTmV2ZXJEZXN0cm95ZWQuaD4KICNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KICNpbXBvcnQg PHd0Zi9UaW55TFJVQ2FjaGUuaD4KQEAgLTExNiwyMCArMTE3LDM1IEBAIE5TQ29sb3IgKm5zQ29s b3IoY29uc3QgQ29sb3ImIGNvbG9yKQogICAgIGlmIChhdXRvIHNyZ2IgPSBjb2xvci50cnlHZXRB c1NSR0JBQnl0ZXMoKSkgewogICAgICAgICBzd2l0Y2ggKFBhY2tlZENvbG9yOjpSR0JBIHsgKnNy Z2IgfS52YWx1ZSkgewogICAgICAgICBjYXNlIFBhY2tlZENvbG9yOjpSR0JBIHsgQ29sb3I6OnRy YW5zcGFyZW50QmxhY2sgfS52YWx1ZTogewotICAgICAgICAgICAgc3RhdGljIE5ldmVyRGVzdHJv eWVkPFJldGFpblB0cjxOU0NvbG9yPj4gY2xlYXJDb2xvciA9IFtOU0NvbG9yIGNvbG9yV2l0aFNS R0JSZWQ6MCBncmVlbjowIGJsdWU6MCBhbHBoYTowXTsKKyAgICAgICAgICAgIHN0YXRpYyBMYXp5 TmV2ZXJEZXN0cm95ZWQ8UmV0YWluUHRyPE5TQ29sb3I+PiBjbGVhckNvbG9yOworICAgICAgICAg ICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIG9uY2VGbGFnOworICAgICAgICAgICAgc3RkOjpjYWxs X29uY2Uob25jZUZsYWcsIFtdIHsKKyAgICAgICAgICAgICAgICBjbGVhckNvbG9yLmNvbnN0cnVj dChbTlNDb2xvciBjb2xvcldpdGhTUkdCUmVkOjAgZ3JlZW46MCBibHVlOjAgYWxwaGE6MF0pOwor ICAgICAgICAgICAgfSk7CiAgICAgICAgICAgICByZXR1cm4gY2xlYXJDb2xvci5nZXQoKS5nZXQo KTsKICAgICAgICAgfQogICAgICAgICBjYXNlIFBhY2tlZENvbG9yOjpSR0JBIHsgQ29sb3I6OmJs YWNrIH0udmFsdWU6IHsKLSAgICAgICAgICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxSZXRhaW5Q dHI8TlNDb2xvcj4+IGJsYWNrQ29sb3IgPSBbTlNDb2xvciBjb2xvcldpdGhTUkdCUmVkOjAgZ3Jl ZW46MCBibHVlOjAgYWxwaGE6MV07CisgICAgICAgICAgICBzdGF0aWMgTGF6eU5ldmVyRGVzdHJv eWVkPFJldGFpblB0cjxOU0NvbG9yPj4gYmxhY2tDb2xvcjsKKyAgICAgICAgICAgIHN0YXRpYyBz dGQ6Om9uY2VfZmxhZyBvbmNlRmxhZzsKKyAgICAgICAgICAgIHN0ZDo6Y2FsbF9vbmNlKG9uY2VG bGFnLCBbXSB7CisgICAgICAgICAgICAgICAgYmxhY2tDb2xvci5jb25zdHJ1Y3QoW05TQ29sb3Ig Y29sb3JXaXRoU1JHQlJlZDowIGdyZWVuOjAgYmx1ZTowIGFscGhhOjFdKTsKKyAgICAgICAgICAg IH0pOwogICAgICAgICAgICAgcmV0dXJuIGJsYWNrQ29sb3IuZ2V0KCkuZ2V0KCk7CiAgICAgICAg IH0KICAgICAgICAgY2FzZSBQYWNrZWRDb2xvcjo6UkdCQSB7IENvbG9yOjp3aGl0ZSB9LnZhbHVl OiB7Ci0gICAgICAgICAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8UmV0YWluUHRyPE5TQ29sb3I+ PiB3aGl0ZUNvbG9yID0gW05TQ29sb3IgY29sb3JXaXRoU1JHQlJlZDoxIGdyZWVuOjEgYmx1ZTox IGFscGhhOjFdOworICAgICAgICAgICAgc3RhdGljIExhenlOZXZlckRlc3Ryb3llZDxSZXRhaW5Q dHI8TlNDb2xvcj4+IHdoaXRlQ29sb3I7CisgICAgICAgICAgICBzdGF0aWMgc3RkOjpvbmNlX2Zs YWcgb25jZUZsYWc7CisgICAgICAgICAgICBzdGQ6OmNhbGxfb25jZShvbmNlRmxhZywgW10gewor ICAgICAgICAgICAgICAgIHdoaXRlQ29sb3IuY29uc3RydWN0KFtOU0NvbG9yIGNvbG9yV2l0aFNS R0JSZWQ6MSBncmVlbjoxIGJsdWU6MSBhbHBoYToxXSk7CisgICAgICAgICAgICB9KTsKICAgICAg ICAgICAgIHJldHVybiB3aGl0ZUNvbG9yLmdldCgpLmdldCgpOwogICAgICAgICB9CiAgICAgICAg IH0KICAgICB9CiAKKyAgICBzdGF0aWMgTG9jayBjYWNoZWRDb2xvckxvY2s7CisgICAgYXV0byBo b2xkZXIgPSBob2xkTG9jayhjYWNoZWRDb2xvckxvY2spOworCiAgICAgc3RhdGljIE5ldmVyRGVz dHJveWVkPFRpbnlMUlVDYWNoZTxDb2xvciwgUmV0YWluUHRyPE5TQ29sb3I+LCAzMj4+IGNhY2hl OwogICAgIHJldHVybiBjYWNoZS5nZXQoKS5nZXQoY29sb3IpLmdldCgpOwogfQo=