226672 2021-06-04 19:11:18 -0700 Reduce use of legacy MainThreadTaskQueue in media code 2021-06-28 08:43:31 -0700 1 1 1 Unclassified WebKit Media WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=227367 InRadar P2 Normal --- 1 cdumez cdumez darin eric.carlson ews-watchlist glenn hta jer.noble philipj sam sergio tommyw webkit-bug-importer oldest_to_newest 1767029 0 cdumez 2021-06-04 19:11:18 -0700 Reduce use of legacy MainThreadTaskQueue in media code. 1767030 1 430639 cdumez 2021-06-04 19:14:43 -0700 Created attachment 430639 Patch 1767092 2 430639 darin 2021-06-04 21:14:48 -0700 Comment on attachment 430639 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=430639&action=review > Source/WebCore/platform/graphics/cocoa/TextTrackRepresentationCocoa.mm:155 > + if (weakThis) > + weakThis->client().textTrackRepresentationBoundsChanged(weakThis->bounds()); Is bounds() guaranteed to not do any work that could have the side effect of destroying this? > Source/WebCore/platform/mediastream/mac/CoreAudioCaptureDeviceManager.cpp:182 > + callOnMainThread([this] { How did you decide a smart pointer (weak pointer or strong pointer) was not needed here? > Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.cpp:79 > + callOnMainThread([this, weakThis = makeWeakPtr(*this)] { > + if (!weakThis) > + return; I prefer the style where we turn weakThis into a RefPtr for the duration of the lambda over the more tricky style where we capture this twice, for both weak and strong pointers. And this is test code so it’s not performance-sensitive. 1767095 3 430639 cdumez 2021-06-04 21:30:49 -0700 Comment on attachment 430639 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=430639&action=review >> Source/WebCore/platform/graphics/cocoa/TextTrackRepresentationCocoa.mm:155 >> + weakThis->client().textTrackRepresentationBoundsChanged(weakThis->bounds()); > > Is bounds() guaranteed to not do any work that could have the side effect of destroying this? bounds() is a fairly simple getter, I don't see any way it can destroy |this|. >> Source/WebCore/platform/mediastream/mac/CoreAudioCaptureDeviceManager.cpp:182 >> + callOnMainThread([this] { > > How did you decide a smart pointer (weak pointer or strong pointer) was not needed here? This class is a singleton. >> Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.cpp:79 >> + return; > > I prefer the style where we turn weakThis into a RefPtr for the duration of the lambda over the more tricky style where we capture this twice, for both weak and strong pointers. And this is test code so it’s not performance-sensitive. Sounds a lot like the ObjC pattern. Something like this? RefPtr protectedThis { weakThis.get() }; if (!protectedThis) return; // ... 1767096 4 430639 cdumez 2021-06-04 21:33:56 -0700 Comment on attachment 430639 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=430639&action=review >>> Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.cpp:79 >>> + return; >> >> I prefer the style where we turn weakThis into a RefPtr for the duration of the lambda over the more tricky style where we capture this twice, for both weak and strong pointers. And this is test code so it’s not performance-sensitive. > > Sounds a lot like the ObjC pattern. Something like this? > RefPtr protectedThis { weakThis.get() }; > if (!protectedThis) > return; > > // ... If I don't capture |this|, it means adding quite a few protectedThis-> here and it other lambda in this file. The previous code was not protecting |this| at all either. 1767097 5 cdumez 2021-06-04 21:39:09 -0700 (In reply to Chris Dumez from comment #4) > Comment on attachment 430639 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=430639&action=review > > >>> Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.cpp:79 > >>> + return; > >> > >> I prefer the style where we turn weakThis into a RefPtr for the duration of the lambda over the more tricky style where we capture this twice, for both weak and strong pointers. And this is test code so it’s not performance-sensitive. > > > > Sounds a lot like the ObjC pattern. Something like this? > > RefPtr protectedThis { weakThis.get() }; > > if (!protectedThis) > > return; > > > > // ... > > If I don't capture |this|, it means adding quite a few protectedThis-> here > and it other lambda in this file. The previous code was not protecting > |this| at all either. I am not a fan of the result: ``` void MediaPlaybackTargetPickerMock::startingMonitoringPlaybackTargets() { LOG(Media, "MediaPlaybackTargetPickerMock::startingMonitoringPlaybackTargets"); callOnMainThread([weakThis = makeWeakPtr(*this)] { RefPtr protectedThis { weakThis.get() }; if (!protectedThis) return; if (protectedThis->m_state == MediaPlaybackTargetContext::MockState::OutputDeviceAvailable) protectedThis->availableDevicesDidChange(); if (!protectedThis->m_deviceName.isEmpty() && protectedThis->m_state != MediaPlaybackTargetContext::MockState::Unknown) protectedThis->currentDeviceDidChange(); }); } ``` Also, I have just found out this class is not even RefCounted :) 1767100 6 430639 darin 2021-06-04 21:40:34 -0700 Comment on attachment 430639 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=430639&action=review >>>> Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.cpp:79 >>>> + return; >>> >>> I prefer the style where we turn weakThis into a RefPtr for the duration of the lambda over the more tricky style where we capture this twice, for both weak and strong pointers. And this is test code so it’s not performance-sensitive. >> >> Sounds a lot like the ObjC pattern. Something like this? >> RefPtr protectedThis { weakThis.get() }; >> if (!protectedThis) >> return; >> >> // ... > > If I don't capture |this|, it means adding quite a few protectedThis-> here and it other lambda in this file. The previous code was not protecting |this| at all either. I understand if you don’t want to go for it; when I said "review+" I didn’t mean you have to make changes based on my comments (just consider them). I’d write my new code that way, but it’s probably asking you too much to do it to this existing code. To avoid all the protectedThis-> we’d need a member function to call from the lambda, which might defeat the points of lambda in coding clarity. But to me object lifetime clarity is one of the most important kinds! 1767109 7 ews-feeder 2021-06-04 22:35:29 -0700 Committed r278522 (238521@main): <https://commits.webkit.org/238521@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 430639. 1767110 8 webkit-bug-importer 2021-06-04 22:36:16 -0700 <rdar://problem/78899303> 430639 2021-06-04 19:14:43 -0700 2021-06-04 22:35:30 -0700 Patch bug-226672-20210604191442.patch text/plain 9731 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjc4NTE2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGVhYzAxMWYzYTk1Mjk5 YmE0MjkyMzdiNDgzODc5YjZhZDYzZjcwYi4uM2JkMzZmMjkzMjE4ZTg3NTU1NTI1MDcxZTBhMzhm NGJiNDRlMzI3ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDIxLTA2LTA0ICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgUmVkdWNlIHVzZSBvZiBsZWdh Y3kgTWFpblRocmVhZFRhc2tRdWV1ZSBpbiBtZWRpYSBjb2RlCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjY2NzIKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWR1Y2UgdXNlIG9mIGxlZ2FjeSBNYWluVGhy ZWFkVGFza1F1ZXVlIGluIG1lZGlhIGNvZGUuIFNpbXBseSB1c2UgY2FsbE9uTWFpblRocmVhZCgp CisgICAgICAgIGZvciB0aGVzZSBpbnN0ZWFkLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvY29jb2EvVGV4dFRyYWNrUmVwcmVzZW50YXRpb25Db2NvYS5oOgorICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL2NvY29hL1RleHRUcmFja1JlcHJlc2VudGF0aW9uQ29jb2EubW06CisgICAg ICAgIChXZWJDb3JlOjpUZXh0VHJhY2tSZXByZXNlbnRhdGlvbkNvY29hOjpib3VuZHNDaGFuZ2Vk KToKKyAgICAgICAgKiBwbGF0Zm9ybS9tZWRpYXN0cmVhbS9pb3MvQVZBdWRpb1Nlc3Npb25DYXB0 dXJlRGV2aWNlTWFuYWdlci5oOgorICAgICAgICAqIHBsYXRmb3JtL21lZGlhc3RyZWFtL21hYy9D b3JlQXVkaW9DYXB0dXJlRGV2aWNlTWFuYWdlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDb3Jl QXVkaW9DYXB0dXJlRGV2aWNlTWFuYWdlcjo6c2NoZWR1bGVVcGRhdGVDYXB0dXJlRGV2aWNlcyk6 CisgICAgICAgICogcGxhdGZvcm0vbWVkaWFzdHJlYW0vbWFjL0NvcmVBdWRpb0NhcHR1cmVEZXZp Y2VNYW5hZ2VyLmg6CisgICAgICAgICogcGxhdGZvcm0vbW9jay9NZWRpYVBsYXliYWNrVGFyZ2V0 UGlja2VyTW9jay5jcHA6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVBsYXliYWNrVGFyZ2V0UGlj a2VyTW9jazo6c2hvd1BsYXliYWNrVGFyZ2V0UGlja2VyKToKKyAgICAgICAgKFdlYkNvcmU6Ok1l ZGlhUGxheWJhY2tUYXJnZXRQaWNrZXJNb2NrOjpzdGFydGluZ01vbml0b3JpbmdQbGF5YmFja1Rh cmdldHMpOgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFQbGF5YmFja1RhcmdldFBpY2tlck1vY2s6 OnNldFN0YXRlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9tb2NrL01lZGlhUGxheWJhY2tUYXJnZXRQ aWNrZXJNb2NrLmg6CisKIDIwMjEtMDYtMDQgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNv bT4KIAogICAgICAgICBGaWxlU3lzdGVtOjpyZWFkRnJvbUZpbGUoKSBzaG91bGQgcmV0dXJuIGRh dGEgYXMgYHZvaWQqYApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY29jb2EvVGV4dFRyYWNrUmVwcmVzZW50YXRpb25Db2NvYS5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvVGV4dFRyYWNrUmVwcmVzZW50YXRpb25Db2NvYS5oCmlu ZGV4IDczOThjNGNlNmE5MzY0M2Y1Nzk3MTg4NWFmOGE0MjQxODE2Njk0OTguLjkyOTliODQ4NDY4 MjE4ZWEzNzM4ZDYwZDc2NmZiN2IwMDk4YTJhMjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2NvY29hL1RleHRUcmFja1JlcHJlc2VudGF0aW9uQ29jb2EuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9UZXh0VHJhY2tSZXBy ZXNlbnRhdGlvbkNvY29hLmgKQEAgLTI4LDE2ICsyOCwxNiBAQAogCiAjaWYgKFBMQVRGT1JNKElP U19GQU1JTFkpIHx8IChQTEFURk9STShNQUMpICYmIEVOQUJMRShWSURFT19QUkVTRU5UQVRJT05f TU9ERSkpKSAmJiBFTkFCTEUoVklERU8pCiAKLSNpbmNsdWRlICJHZW5lcmljVGFza1F1ZXVlLmgi CiAjaW5jbHVkZSAiVGV4dFRyYWNrUmVwcmVzZW50YXRpb24uaCIKICNpbmNsdWRlIDxRdWFydHpD b3JlL0NBTGF5ZXIuaD4KICNpbmNsdWRlIDx3dGYvUmV0YWluUHRyLmg+CisjaW5jbHVkZSA8d3Rm L1dlYWtQdHIuaD4KIAogQGNsYXNzIFdlYkNvcmVUZXh0VHJhY2tSZXByZXNlbnRhdGlvbkNvY29h SGVscGVyOwogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLWNsYXNzIFRleHRUcmFja1JlcHJlc2Vu dGF0aW9uQ29jb2EgZmluYWwgOiBwdWJsaWMgVGV4dFRyYWNrUmVwcmVzZW50YXRpb24geworY2xh c3MgVGV4dFRyYWNrUmVwcmVzZW50YXRpb25Db2NvYSBmaW5hbCA6IHB1YmxpYyBUZXh0VHJhY2tS ZXByZXNlbnRhdGlvbiwgcHVibGljIENhbk1ha2VXZWFrUHRyPFRleHRUcmFja1JlcHJlc2VudGF0 aW9uQ29jb2EsIFdlYWtQdHJGYWN0b3J5SW5pdGlhbGl6YXRpb246OkVhZ2VyPiB7CiBwdWJsaWM6 CiAgICAgZXhwbGljaXQgVGV4dFRyYWNrUmVwcmVzZW50YXRpb25Db2NvYShUZXh0VHJhY2tSZXBy ZXNlbnRhdGlvbkNsaWVudCYpOwogICAgIHZpcnR1YWwgflRleHRUcmFja1JlcHJlc2VudGF0aW9u Q29jb2EoKTsKQEAgLTU0LDcgKzU0LDYgQEAgcHJpdmF0ZToKICAgICB2b2lkIHNldENvbnRlbnRT Y2FsZShmbG9hdCkgZmluYWw7CiAgICAgdm9pZCBzZXRIaWRkZW4oYm9vbCkgY29uc3QgZmluYWw7 CiAKLSAgICBNYWluVGhyZWFkVGFza1F1ZXVlIG1fdGFza1F1ZXVlOwogICAgIFRleHRUcmFja1Jl cHJlc2VudGF0aW9uQ2xpZW50JiBtX2NsaWVudDsKICAgICBSZXRhaW5QdHI8Q0FMYXllcj4gbV9s YXllcjsKICAgICBSZXRhaW5QdHI8V2ViQ29yZVRleHRUcmFja1JlcHJlc2VudGF0aW9uQ29jb2FI ZWxwZXI+IG1fZGVsZWdhdGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jb2NvYS9UZXh0VHJhY2tSZXByZXNlbnRhdGlvbkNvY29hLm1tIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvVGV4dFRyYWNrUmVwcmVzZW50YXRpb25Db2Nv YS5tbQppbmRleCBiOTg3MTkwOWVjM2U3YTkyNGI3NzdhNGNhNDFhYjQ3OGY3YTdjZDE0Li40YTU1 NTMxNjJhOTYzYWJhNjg4MjYzNTU0ZDE3ZDBlNmZhZDBiMDQ2IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9UZXh0VHJhY2tSZXByZXNlbnRhdGlvbkNv Y29hLm1tCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NvY29hL1RleHRU cmFja1JlcHJlc2VudGF0aW9uQ29jb2EubW0KQEAgLTE1MCw4ICsxNTAsOSBAQCBJbnRSZWN0IFRl eHRUcmFja1JlcHJlc2VudGF0aW9uQ29jb2E6OmJvdW5kcygpIGNvbnN0CiAKIHZvaWQgVGV4dFRy YWNrUmVwcmVzZW50YXRpb25Db2NvYTo6Ym91bmRzQ2hhbmdlZCgpCiB7Ci0gICAgbV90YXNrUXVl dWUuZW5xdWV1ZVRhc2soW3RoaXNdICgpIHsKLSAgICAgICAgY2xpZW50KCkudGV4dFRyYWNrUmVw cmVzZW50YXRpb25Cb3VuZHNDaGFuZ2VkKGJvdW5kcygpKTsKKyAgICBjYWxsT25NYWluVGhyZWFk KFt3ZWFrVGhpcyA9IG1ha2VXZWFrUHRyKCp0aGlzKV0geworICAgICAgICBpZiAod2Vha1RoaXMp CisgICAgICAgICAgICB3ZWFrVGhpcy0+Y2xpZW50KCkudGV4dFRyYWNrUmVwcmVzZW50YXRpb25C b3VuZHNDaGFuZ2VkKHdlYWtUaGlzLT5ib3VuZHMoKSk7CiAgICAgfSk7CiB9CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL2lvcy9BVkF1ZGlvU2Vzc2lv bkNhcHR1cmVEZXZpY2VNYW5hZ2VyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0 cmVhbS9pb3MvQVZBdWRpb1Nlc3Npb25DYXB0dXJlRGV2aWNlTWFuYWdlci5oCmluZGV4IGUzNjBh YjQzZTRmNzVlMDRmNjVkNzYwYzJiNTFjMjYyOTUyODQ1NGMuLmFmNDk3ZDJlMThlNmQ1NTdlNDk0 M2IxOTRhZmY0OGRhN2I0NjY3ZTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L21lZGlhc3RyZWFtL2lvcy9BVkF1ZGlvU2Vzc2lvbkNhcHR1cmVEZXZpY2VNYW5hZ2VyLmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vaW9zL0FWQXVkaW9TZXNzaW9u Q2FwdHVyZURldmljZU1hbmFnZXIuaApAQCAtNzUsNyArNzUsNiBAQCBwcml2YXRlOgogICAgIHN0 ZDo6b3B0aW9uYWw8VmVjdG9yPEFWQXVkaW9TZXNzaW9uQ2FwdHVyZURldmljZT4+IG1fYXVkaW9T ZXNzaW9uQ2FwdHVyZURldmljZXM7CiAgICAgUmV0YWluUHRyPFdlYkFWQXVkaW9TZXNzaW9uQXZh aWxhYmxlSW5wdXRzTGlzdGVuZXI+IG1fbGlzdGVuZXI7CiAgICAgUmV0YWluUHRyPEFWQXVkaW9T ZXNzaW9uPiBtX2F1ZGlvU2Vzc2lvbjsKLSAgICBNYWluVGhyZWFkVGFza1F1ZXVlIG1fdXBkYXRl RGV2aWNlU3RhdGVRdWV1ZTsKICAgICBSZWY8V29ya1F1ZXVlPiBtX2Rpc3BhdGNoUXVldWU7CiAg ICAgQXVkaW9TZXNzaW9uU3RhdGUgbV9hdWRpb1Nlc3Npb25TdGF0ZSB7IEF1ZGlvU2Vzc2lvblN0 YXRlOjpOb3ROZWVkZWQgfTsKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9tZWRpYXN0cmVhbS9tYWMvQ29yZUF1ZGlvQ2FwdHVyZURldmljZU1hbmFnZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vbWFjL0NvcmVBdWRpb0NhcHR1cmVEZXZp Y2VNYW5hZ2VyLmNwcAppbmRleCA0ZGUwMGM5MDU3NThkMjQ2NWZhYjNhZTVlMTkwZjI1NzhiOThi YmU2Li44M2M4NTBlNDkyMjMyOWY2ZWU4NzRjNTg2M2ViNzRlNzkxMGMwNzBhIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9tYWMvQ29yZUF1ZGlvQ2FwdHVy ZURldmljZU1hbmFnZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3Ry ZWFtL21hYy9Db3JlQXVkaW9DYXB0dXJlRGV2aWNlTWFuYWdlci5jcHAKQEAgLTE3NSwxMSArMTc1 LDEzIEBAIHN0YXRpYyBib29sIGlzVmFsaWRDYXB0dXJlRGV2aWNlKGNvbnN0IENvcmVBdWRpb0Nh cHR1cmVEZXZpY2UmIGRldmljZSkKIAogdm9pZCBDb3JlQXVkaW9DYXB0dXJlRGV2aWNlTWFuYWdl cjo6c2NoZWR1bGVVcGRhdGVDYXB0dXJlRGV2aWNlcygpCiB7Ci0gICAgaWYgKG1fdXBkYXRlRGV2 aWNlU3RhdGVRdWV1ZS5oYXNQZW5kaW5nVGFza3MoKSkKKyAgICBpZiAobV93YXNSZWZyZXNoQXVk aW9DYXB0dXJlRGV2aWNlc1NjaGVkdWxlZCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgbV91cGRh dGVEZXZpY2VTdGF0ZVF1ZXVlLmVucXVldWVUYXNrKFt0aGlzXSB7CisgICAgbV93YXNSZWZyZXNo QXVkaW9DYXB0dXJlRGV2aWNlc1NjaGVkdWxlZCA9IHRydWU7CisgICAgY2FsbE9uTWFpblRocmVh ZChbdGhpc10gewogICAgICAgICByZWZyZXNoQXVkaW9DYXB0dXJlRGV2aWNlcyhOb3RpZnlJZkRl dmljZXNIYXZlQ2hhbmdlZDo6Tm90aWZ5KTsKKyAgICAgICAgbV93YXNSZWZyZXNoQXVkaW9DYXB0 dXJlRGV2aWNlc1NjaGVkdWxlZCA9IGZhbHNlOwogICAgIH0pOwogfQogCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9tYWMvQ29yZUF1ZGlvQ2FwdHVyZURl dmljZU1hbmFnZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL21hYy9D b3JlQXVkaW9DYXB0dXJlRGV2aWNlTWFuYWdlci5oCmluZGV4IDU0MWU5NDhmYTVkNmUxZDczMWZi YzMyYmQxNjgwMDI3YjM3YTdlMmMuLjJlMTIwZTc0MjcwOGQ4NmUzMTA1YzMxMWU1NjRmYTllYjcy N2QwNDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL21h Yy9Db3JlQXVkaW9DYXB0dXJlRGV2aWNlTWFuYWdlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL21lZGlhc3RyZWFtL21hYy9Db3JlQXVkaW9DYXB0dXJlRGV2aWNlTWFuYWdlci5oCkBA IC0yOSw3ICsyOSw2IEBACiAKICNpbmNsdWRlICJDYXB0dXJlRGV2aWNlLmgiCiAjaW5jbHVkZSAi Q2FwdHVyZURldmljZU1hbmFnZXIuaCIKLSNpbmNsdWRlICJHZW5lcmljVGFza1F1ZXVlLmgiCiAj aW5jbHVkZSA8Q29yZUF1ZGlvL0NvcmVBdWRpby5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0 cmluZy5oPgogCkBAIC02MSw3ICs2MCw3IEBAIHByaXZhdGU6CiAgICAgVmVjdG9yPENhcHR1cmVE ZXZpY2U+IG1fY2FwdHVyZURldmljZXM7CiAgICAgVmVjdG9yPENhcHR1cmVEZXZpY2U+IG1fc3Bl YWtlckRldmljZXM7CiAgICAgVmVjdG9yPENvcmVBdWRpb0NhcHR1cmVEZXZpY2U+IG1fY29yZUF1 ZGlvQ2FwdHVyZURldmljZXM7Ci0gICAgTWFpblRocmVhZFRhc2tRdWV1ZSBtX3VwZGF0ZURldmlj ZVN0YXRlUXVldWU7CisgICAgYm9vbCBtX3dhc1JlZnJlc2hBdWRpb0NhcHR1cmVEZXZpY2VzU2No ZWR1bGVkIHsgZmFsc2UgfTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21vY2svTWVkaWFQbGF5YmFja1RhcmdldFBpY2tl ck1vY2suY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbW9jay9NZWRpYVBsYXliYWNrVGFy Z2V0UGlja2VyTW9jay5jcHAKaW5kZXggM2IwY2E2YTc4MzcyM2Y4Zjk4ZDIyNjBhYWI2YWI1YTU2 MWVlMWM0OS4uNzMwNGJmY2VhYzg0YjIzMTI2MWZhZGRiNGIzNmQ4NzU2MGQ0MTQ3OSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbW9jay9NZWRpYVBsYXliYWNrVGFyZ2V0UGlj a2VyTW9jay5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbW9jay9NZWRpYVBsYXli YWNrVGFyZ2V0UGlja2VyTW9jay5jcHAKQEAgLTc0LDcgKzc0LDEwIEBAIHZvaWQgTWVkaWFQbGF5 YmFja1RhcmdldFBpY2tlck1vY2s6OnNob3dQbGF5YmFja1RhcmdldFBpY2tlcihQbGF0Zm9ybVZp ZXcqLCBjb25zCiAgICAgTE9HKE1lZGlhLCAiTWVkaWFQbGF5YmFja1RhcmdldFBpY2tlck1vY2s6 OnNob3dQbGF5YmFja1RhcmdldFBpY2tlciAtIGNoZWNrQWN0aXZlUm91dGUgPSAlaSwgdXNlRGFy a0FwcGVhcmFuY2UgPSAlaSIsIChpbnQpY2hlY2tBY3RpdmVSb3V0ZSwgKGludCl1c2VEYXJrQXBw ZWFyYW5jZSk7CiAKICAgICBtX3Nob3dpbmdNZW51ID0gdHJ1ZTsKLSAgICBtX3Rhc2tRdWV1ZS5l bnF1ZXVlVGFzayhbdGhpc10geworICAgIGNhbGxPbk1haW5UaHJlYWQoW3RoaXMsIHdlYWtUaGlz ID0gbWFrZVdlYWtQdHIoKnRoaXMpXSB7CisgICAgICAgIGlmICghd2Vha1RoaXMpCisgICAgICAg ICAgICByZXR1cm47CisKICAgICAgICAgbV9zaG93aW5nTWVudSA9IGZhbHNlOwogICAgICAgICBj dXJyZW50RGV2aWNlRGlkQ2hhbmdlKCk7CiAgICAgfSk7CkBAIC04NCw3ICs4NywxMCBAQCB2b2lk IE1lZGlhUGxheWJhY2tUYXJnZXRQaWNrZXJNb2NrOjpzdGFydGluZ01vbml0b3JpbmdQbGF5YmFj a1RhcmdldHMoKQogewogICAgIExPRyhNZWRpYSwgIk1lZGlhUGxheWJhY2tUYXJnZXRQaWNrZXJN b2NrOjpzdGFydGluZ01vbml0b3JpbmdQbGF5YmFja1RhcmdldHMiKTsKIAotICAgIG1fdGFza1F1 ZXVlLmVucXVldWVUYXNrKFt0aGlzXSB7CisgICAgY2FsbE9uTWFpblRocmVhZChbdGhpcywgd2Vh a1RoaXMgPSBtYWtlV2Vha1B0cigqdGhpcyldIHsKKyAgICAgICAgaWYgKCF3ZWFrVGhpcykKKyAg ICAgICAgICAgIHJldHVybjsKKwogICAgICAgICBpZiAobV9zdGF0ZSA9PSBNZWRpYVBsYXliYWNr VGFyZ2V0Q29udGV4dDo6TW9ja1N0YXRlOjpPdXRwdXREZXZpY2VBdmFpbGFibGUpCiAgICAgICAg ICAgICBhdmFpbGFibGVEZXZpY2VzRGlkQ2hhbmdlKCk7CiAKQEAgLTEwOCw3ICsxMTQsMTAgQEAg dm9pZCBNZWRpYVBsYXliYWNrVGFyZ2V0UGlja2VyTW9jazo6c2V0U3RhdGUoY29uc3QgU3RyaW5n JiBkZXZpY2VOYW1lLCBNZWRpYVBsYXkKIHsKICAgICBMT0coTWVkaWEsICJNZWRpYVBsYXliYWNr VGFyZ2V0UGlja2VyTW9jazo6c2V0U3RhdGUgLSBuYW1lID0gJXMsIHN0YXRlID0gMHgleCIsIGRl dmljZU5hbWUudXRmOCgpLmRhdGEoKSwgKHVuc2lnbmVkKXN0YXRlKTsKIAotICAgIG1fdGFza1F1 ZXVlLmVucXVldWVUYXNrKFt0aGlzLCBzdGF0ZSwgZGV2aWNlTmFtZV0geworICAgIGNhbGxPbk1h aW5UaHJlYWQoW3RoaXMsIHdlYWtUaGlzID0gbWFrZVdlYWtQdHIoKnRoaXMpLCBzdGF0ZSwgZGV2 aWNlTmFtZV0geworICAgICAgICBpZiAoIXdlYWtUaGlzKQorICAgICAgICAgICAgcmV0dXJuOwor CiAgICAgICAgIGlmIChkZXZpY2VOYW1lICE9IG1fZGV2aWNlTmFtZSAmJiBzdGF0ZSAhPSBNZWRp YVBsYXliYWNrVGFyZ2V0Q29udGV4dDo6TW9ja1N0YXRlOjpVbmtub3duKSB7CiAgICAgICAgICAg ICBtX2RldmljZU5hbWUgPSBkZXZpY2VOYW1lOwogICAgICAgICAgICAgY3VycmVudERldmljZURp ZENoYW5nZSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbW9jay9NZWRp YVBsYXliYWNrVGFyZ2V0UGlja2VyTW9jay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbW9j ay9NZWRpYVBsYXliYWNrVGFyZ2V0UGlja2VyTW9jay5oCmluZGV4IDBmNmU5ODI2MjEyZGRhZmM4 NzA2MTFkMmUxZGM5NDdiMDRlNmMzZDguLjgzZDU5YTc2NmQzOWZkMmFkNWVmMjVlZGI0ZjNjNjZm YjQ3OGYyOTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21vY2svTWVkaWFQ bGF5YmFja1RhcmdldFBpY2tlck1vY2suaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9t b2NrL01lZGlhUGxheWJhY2tUYXJnZXRQaWNrZXJNb2NrLmgKQEAgLTI4LDE0ICsyOCwxMyBAQAog CiAjaWYgRU5BQkxFKFdJUkVMRVNTX1BMQVlCQUNLX1RBUkdFVCkgJiYgIVBMQVRGT1JNKElPU19G QU1JTFkpCiAKLSNpbmNsdWRlICJHZW5lcmljVGFza1F1ZXVlLmgiCiAjaW5jbHVkZSAiTWVkaWFQ bGF5YmFja1RhcmdldENvbnRleHQuaCIKICNpbmNsdWRlICJNZWRpYVBsYXliYWNrVGFyZ2V0UGlj a2VyLmgiCiAjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAotY2xhc3MgTWVkaWFQbGF5YmFja1RhcmdldFBpY2tlck1vY2sgZmluYWwgOiBwdWJs aWMgTWVkaWFQbGF5YmFja1RhcmdldFBpY2tlciB7CitjbGFzcyBNZWRpYVBsYXliYWNrVGFyZ2V0 UGlja2VyTW9jayBmaW5hbCA6IHB1YmxpYyBNZWRpYVBsYXliYWNrVGFyZ2V0UGlja2VyLCBwdWJs aWMgQ2FuTWFrZVdlYWtQdHI8TWVkaWFQbGF5YmFja1RhcmdldFBpY2tlck1vY2s+IHsKICAgICBX VEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShNZWRpYVBs YXliYWNrVGFyZ2V0UGlja2VyTW9jayk7CiBwdWJsaWM6CkBAIC01Niw3ICs1NSw2IEBAIHByaXZh dGU6CiAgICAgUmVmPE1lZGlhUGxheWJhY2tUYXJnZXQ+IHBsYXliYWNrVGFyZ2V0KCkgb3ZlcnJp ZGU7CiAKICAgICBTdHJpbmcgbV9kZXZpY2VOYW1lOwotICAgIE1haW5UaHJlYWRUYXNrUXVldWUg bV90YXNrUXVldWU7CiAgICAgTWVkaWFQbGF5YmFja1RhcmdldENvbnRleHQ6Ok1vY2tTdGF0ZSBt X3N0YXRlIHsgTWVkaWFQbGF5YmFja1RhcmdldENvbnRleHQ6Ok1vY2tTdGF0ZTo6VW5rbm93biB9 OwogICAgIGJvb2wgbV9zaG93aW5nTWVudSB7IGZhbHNlIH07CiB9Owo=