132667 2014-05-07 17:31:06 -0700 [iOS WebKit2] Flush RemoteLayerBackingStore contexts on a secondary queue 2014-05-10 14:21:48 -0700 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 thorton thorton andersca commit-queue mitz psolanki sam simon.fraser oldest_to_newest 1007476 0 thorton 2014-05-07 17:31:06 -0700 We can do this expensive and blocking work on a queue, and send the CommitLayerTree message once it's done, and let the Web process continue on with JS or layout or whatever it wants to do (that isn't painting). <rdar://problem/15349483> 1007513 1 231040 thorton 2014-05-07 21:08:02 -0700 Created attachment 231040 patch 1007516 2 commit-queue 2014-05-07 21:10:37 -0700 Attachment 231040 did not pass style-queue: ERROR: Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:292: Missing space before { [whitespace/braces] [5] Total errors found: 1 in 5 files If any of these errors are false positives, please file a bug against check-webkit-style. 1007617 3 231040 andersca 2014-05-08 08:15:23 -0700 Comment on attachment 231040 patch View in context: https://bugs.webkit.org/attachment.cgi?id=231040&action=review > Source/WebKit2/Shared/mac/RemoteLayerBackingStore.mm:360 > + RetainPtr<CGContextRef> frontContextPendingFlush = m_frontContextPendingFlush; > + m_frontContextPendingFlush = nullptr; This can just be RetainPtr<CGContextRef> frontContextPendingFlush = std::move(m_frontContextPendingFlush); or even auto frontContextPendingFlush = std::move(m_frontContextPendingFlush); > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:69 > + m_commitQueue = dispatch_queue_create("com.apple.WebKit.WebContent.RemoteLayerTreeDrawingAreaCommitQueue", nullptr); I'd put another period before CommitQueue. > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:280 > + RetainPtr<CGContextRef> contextPendingFlush = layer->properties().backingStore->takeFrontContextPendingFlush(); > + if (contextPendingFlush) > + contextsToFlush.append(contextPendingFlush); if (auto contextPendingFlush = ...) contextToFlush.append(std::move(contextPendingFlush)); > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:289 > + RefPtr<BackingStoreFlusher> backingStoreFlusher = BackingStoreFlusher::create(WebProcess::shared().parentProcessConnection(), std::move(commitEncoder), contextsToFlush); std::move(contextsToFlush). > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:292 > + dispatch_async(m_commitQueue, [backingStoreFlusher](){ No need for () in the lambda. 1007720 4 231040 darin 2014-05-08 12:32:33 -0700 Comment on attachment 231040 patch View in context: https://bugs.webkit.org/attachment.cgi?id=231040&action=review >> Source/WebKit2/Shared/mac/RemoteLayerBackingStore.mm:360 >> + m_frontContextPendingFlush = nullptr; > > This can just be > > RetainPtr<CGContextRef> frontContextPendingFlush = std::move(m_frontContextPendingFlush); > > or even > > auto frontContextPendingFlush = std::move(m_frontContextPendingFlush); Can it be this? return std::move(m_frontContextPendingFlush); > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h:108 > + BackingStoreFlusher(IPC::Connection*, std::unique_ptr<IPC::MessageEncoder>, Vector<RetainPtr<CGContextRef>>); I’m surprised to see both a public constructor and a create function. > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h:118 > + std::atomic<bool> m_hasFlushed; I don’t fully understand the use of std::atomic here. It doesn’t seem sufficient for the cross-thread synchronization I expect would be needed. Maybe it’s just helping the RELEASE_ASSERT work reliably? > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:245 > + RELEASE_ASSERT(!m_pendingBackingStoreFlusher || m_pendingBackingStoreFlusher->hasFlushed()); Wow, RELEASE_ASSERT. We are getting more liberal with those lately. What guarantees that the backing store flusher has flushed at this point? > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:322 > + return adoptRef(new RemoteLayerTreeDrawingArea::BackingStoreFlusher(connection, std::move(encoder), contextsToFlush)); Would a std::move(contextsToFlush) help efficiency here? > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:328 > + , m_contextsToFlush(contextsToFlush) Would a std::move(contextsToFlush) here help efficiency? > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:329 > + , m_hasFlushed(false) Is this needed? Doesn’t an std::atomic<bool> automatically get initialized to false? > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:339 > + for (auto& context : m_contextsToFlush) > + CGContextFlush(context.get()); > + > + m_connection->sendMessage(std::move(m_commitEncoder)); > + m_hasFlushed = true; This should either have: ASSERT(!m_hasFlushed); or if (m_hasFlushed) return; Or maybe there’s some good reason neither is needed. 1007752 5 thorton 2014-05-08 13:22:41 -0700 (In reply to comment #4) > (From update of attachment 231040 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=231040&action=review > > >> Source/WebKit2/Shared/mac/RemoteLayerBackingStore.mm:360 > >> + m_frontContextPendingFlush = nullptr; > > > > This can just be > > > > RetainPtr<CGContextRef> frontContextPendingFlush = std::move(m_frontContextPendingFlush); > > > > or even > > > > auto frontContextPendingFlush = std::move(m_frontContextPendingFlush); > > Can it be this? > > return std::move(m_frontContextPendingFlush); > > > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h:108 > > + BackingStoreFlusher(IPC::Connection*, std::unique_ptr<IPC::MessageEncoder>, Vector<RetainPtr<CGContextRef>>); > > I’m surprised to see both a public constructor and a create function. Whoops! > > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h:118 > > + std::atomic<bool> m_hasFlushed; > > I don’t fully understand the use of std::atomic here. It doesn’t seem sufficient for the cross-thread synchronization I expect would be needed. Maybe it’s just helping the RELEASE_ASSERT work reliably? Purely for the RELEASE_ASSERT to work reliably; the synchronization is actually performed through another slightly more ridiculous mechanism described below. > > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:245 > > + RELEASE_ASSERT(!m_pendingBackingStoreFlusher || m_pendingBackingStoreFlusher->hasFlushed()); > > Wow, RELEASE_ASSERT. We are getting more liberal with those lately. > > What guarantees that the backing store flusher has flushed at this point? The fact that we will bail from flushLayers() until we’ve heard back from the UI process (due to m_waitingForBackingStoreSwap), and we can only hear back from the UI process if we’ve sent it a new layer tree to commit, which happens from inside the backing store flusher! The RELEASE_ASSERT is simply to ensure that that mechanism is always working (if it fails, we’ll start painting garbage). Getting crash logs in that (very unlikely) case seem much more useful than murmurs of slightly incorrect painting. We’ll keep an eye on it, in any case. > > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:322 > > + return adoptRef(new RemoteLayerTreeDrawingArea::BackingStoreFlusher(connection, std::move(encoder), contextsToFlush)); > > Would a std::move(contextsToFlush) help efficiency here? > > > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:328 > > + , m_contextsToFlush(contextsToFlush) > > Would a std::move(contextsToFlush) here help efficiency? > > > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:329 > > + , m_hasFlushed(false) > > Is this needed? Doesn’t an std::atomic<bool> automatically get initialized to false? Anders says std::atomic doesn’t initialize. > > Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:339 > > + for (auto& context : m_contextsToFlush) > > + CGContextFlush(context.get()); > > + > > + m_connection->sendMessage(std::move(m_commitEncoder)); > > + m_hasFlushed = true; > > This should either have: > > ASSERT(!m_hasFlushed); > > or > > if (m_hasFlushed) > return; > > Or maybe there’s some good reason neither is needed. We make a new one each time through flushLayers(), and only call flush on it once? I’m fine with an ASSERT, though. 1007762 6 thorton 2014-05-08 13:57:25 -0700 http://trac.webkit.org/changeset/168493 1007829 7 thorton 2014-05-08 17:22:46 -0700 Crash fix in http://trac.webkit.org/changeset/168509 1007979 8 231040 darin 2014-05-09 07:38:19 -0700 Comment on attachment 231040 patch View in context: https://bugs.webkit.org/attachment.cgi?id=231040&action=review >>> Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:322 >>> + return adoptRef(new RemoteLayerTreeDrawingArea::BackingStoreFlusher(connection, std::move(encoder), contextsToFlush)); >> >> Would a std::move(contextsToFlush) help efficiency here? > > Anders says std::atomic doesn’t initialize. Looking at the patch that was landed, it looks like you missed the comment here about std::move(contextsToFlush), so we’ll be making a copy here. 1008068 9 thorton 2014-05-09 12:27:22 -0700 (In reply to comment #8) > (From update of attachment 231040 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=231040&action=review > > >>> Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:322 > >>> + return adoptRef(new RemoteLayerTreeDrawingArea::BackingStoreFlusher(connection, std::move(encoder), contextsToFlush)); > >> > >> Would a std::move(contextsToFlush) help efficiency here? > > > > Anders says std::atomic doesn’t initialize. > > Looking at the patch that was landed, it looks like you missed the comment here about std::move(contextsToFlush), so we’ll be making a copy here. You're right, I totally missed that one. Will fix. 1008069 10 thorton 2014-05-09 12:32:36 -0700 (In reply to comment #9) > (In reply to comment #8) > > (From update of attachment 231040 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=231040&action=review > > > > >>> Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:322 > > >>> + return adoptRef(new RemoteLayerTreeDrawingArea::BackingStoreFlusher(connection, std::move(encoder), contextsToFlush)); > > >> > > >> Would a std::move(contextsToFlush) help efficiency here? > > > > > > Anders says std::atomic doesn’t initialize. > > > > Looking at the patch that was landed, it looks like you missed the comment here about std::move(contextsToFlush), so we’ll be making a copy here. > > You're right, I totally missed that one. Will fix. Fixed in http://trac.webkit.org/changeset/168544. 1008304 11 thorton 2014-05-10 14:21:48 -0700 This also caused https://bugs.webkit.org/show_bug.cgi?id=132783. 231040 2014-05-07 21:08:02 -0700 2014-05-09 07:38:19 -0700 patch flush-secondary.diff text/plain 10909 thorton ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCAxYjA2MGFmLi5iMGQxZDg0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzYg QEAKKzIwMTQtMDUtMDcgIFRpbSBIb3J0b24gIDx0aW1vdGh5X2hvcnRvbkBhcHBsZS5jb20+CisK KyAgICAgICAgW2lPUyBXZWJLaXQyXSBGbHVzaCBSZW1vdGVMYXllckJhY2tpbmdTdG9yZSBjb250 ZXh0cyBvbiBhIHNlY29uZGFyeSBxdWV1ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTMyNjY3CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8xNTM0OTQ4 Mz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFNo YXJlZC9tYWMvUmVtb3RlTGF5ZXJCYWNraW5nU3RvcmUuaDoKKyAgICAgICAgKiBTaGFyZWQvbWFj L1JlbW90ZUxheWVyQmFja2luZ1N0b3JlLm1tOgorICAgICAgICAoV2ViS2l0OjpSZW1vdGVMYXll ckJhY2tpbmdTdG9yZTo6dGFrZUZyb250Q29udGV4dFBlbmRpbmdGbHVzaCk6CisgICAgICAgIChX ZWJLaXQ6OlJlbW90ZUxheWVyQmFja2luZ1N0b3JlOjpmbHVzaCk6IERlbGV0ZWQuCisgICAgICAg IEFkZCB0YWtlRnJvbnRDb250ZXh0UGVuZGluZ0ZsdXNoLCB3aGljaCByZXR1cm5zIHRoZSBwYWlu dGVkLWJ1dC1ub3QteWV0LWZsdXNoZWQgZnJvbnQgY29udGV4dCwKKyAgICAgICAgYW5kIGRyb3Bz IG91ciByZWZlcmVuY2UgdG8gaXQuIFRoaXMgbmVlZHMgdG8gYmUgY2FsbGVkIG9uIGFsbCBiYWNr aW5nIHN0b3JlIGJldHdlZW4gcGFpbnRzLgorCisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdl L21hYy9SZW1vdGVMYXllclRyZWVEcmF3aW5nQXJlYS5oOgorICAgICAgICAoV2ViS2l0OjpSZW1v dGVMYXllclRyZWVEcmF3aW5nQXJlYTo6QmFja2luZ1N0b3JlRmx1c2hlcjo6aGFzRmx1c2hlZCk6 CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL21hYy9SZW1vdGVMYXllclRyZWVEcmF3aW5n QXJlYS5tbToKKyAgICAgICAgKFdlYktpdDo6UmVtb3RlTGF5ZXJUcmVlRHJhd2luZ0FyZWE6OlJl bW90ZUxheWVyVHJlZURyYXdpbmdBcmVhKToKKyAgICAgICAgKFdlYktpdDo6UmVtb3RlTGF5ZXJU cmVlRHJhd2luZ0FyZWE6On5SZW1vdGVMYXllclRyZWVEcmF3aW5nQXJlYSk6CisgICAgICAgIChX ZWJLaXQ6OlJlbW90ZUxheWVyVHJlZURyYXdpbmdBcmVhOjpmbHVzaExheWVycyk6CisgICAgICAg IChXZWJLaXQ6OlJlbW90ZUxheWVyVHJlZURyYXdpbmdBcmVhOjpCYWNraW5nU3RvcmVGbHVzaGVy OjpjcmVhdGUpOgorICAgICAgICAoV2ViS2l0OjpSZW1vdGVMYXllclRyZWVEcmF3aW5nQXJlYTo6 QmFja2luZ1N0b3JlRmx1c2hlcjo6QmFja2luZ1N0b3JlRmx1c2hlcik6CisgICAgICAgIChXZWJL aXQ6OlJlbW90ZUxheWVyVHJlZURyYXdpbmdBcmVhOjpCYWNraW5nU3RvcmVGbHVzaGVyOjpmbHVz aCk6CisgICAgICAgIChXZWJLaXQ6OmZsdXNoQmFja2luZ1N0b3JlQ2hhbmdlc0luVHJhbnNhY3Rp b24pOiBEZWxldGVkLgorICAgICAgICBGbHVzaCBiYWNraW5nIHN0b3JlIGFuZCBzZW5kIHRoZSBs YXllciB0cmVlIGNvbW1pdCB0byB0aGUgVUkgcHJvY2VzcyBmcm9tIGEgZGlzcGF0Y2ggcXVldWUu CisgICAgICAgIFdlIHdpbGwgb25seSBldmVyIGhhdmUgYSBzaW5nbGUgY29tbWl0IGluIGZsaWdo dCBhdCBhIHRpbWUsIGFuZCB0aGVyZSdzIGEgbmV3CisgICAgICAgIFJFTEVBU0VfQVNTRVJUIHRv IGVuc3VyZSB0aGF0IGlzIHRoZSBjYXNlLgorICAgICAgICBXZSBwYWNrYWdlIHVwIHRoZSBjb21t aXQgb24gdGhlIG1haW4gdGhyZWFkOyB0aGUgcXVldWUgY2FsbHMgQ0dDb250ZXh0Rmx1c2gKKyAg ICAgICAgb24gYWxsIG9mIHRoZSBuZXdseSBwYWludGVkIGNvbnRleHRzIGFuZCB0aGVuIHRvc3Nl cyB0aGUgY29tbWl0IG92ZXIgdG8gdGhlIFVJIHByb2Nlc3MuCisgICAgICAgIFRoaXMgaXMgYSB3 aW4gaW4gbWFueSBjYXNlcyBiZWNhdXNlIHRoZSBXZWIgcHJvY2VzcyBtYWluIHRocmVhZCBjYW4g Z28gYWhlYWQKKyAgICAgICAgYW5kIGRvIG90aGVyIG5vbi1wYWludGluZyB0YXNrcyB3aGlsZSB0 aGUgcXVldWUgaXMgYmxvY2tlZCBvbiBwYWludGluZy4KKwogMjAxNC0wNS0wNyAgSmVyZW15IEpv bmVzICA8amVyZW15akBhcHBsZS5jb20+CiAKICAgICAgICAgSFRNTE1lZGlhRWxlbWVudCBzaG91 bGQgZXhpdEZ1bGxzY3JlZW4gd2hlbiB2aWV3IGlzIHJlbW92ZWQgZnJvbSB0aGUgd2luZG93Lgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL21hYy9SZW1vdGVMYXllckJhY2tpbmdT dG9yZS5oIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL21hYy9SZW1vdGVMYXllckJhY2tpbmdTdG9y ZS5oCmluZGV4IGMwYWRhODkuLjM5YzkxNzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1No YXJlZC9tYWMvUmVtb3RlTGF5ZXJCYWNraW5nU3RvcmUuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9T aGFyZWQvbWFjL1JlbW90ZUxheWVyQmFja2luZ1N0b3JlLmgKQEAgLTgxLDcgKzgxLDcgQEAgcHVi bGljOgogICAgICAgICByZXR1cm4gISFtX2Zyb250QnVmZmVyOwogICAgIH0KIAotICAgIHZvaWQg Zmx1c2goKTsKKyAgICBSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiB0YWtlRnJvbnRDb250ZXh0UGVu ZGluZ0ZsdXNoKCk7CiAKICAgICBlbnVtIGNsYXNzIFZvbGF0aWxpdHkgewogICAgICAgICBOb25W b2xhdGlsZSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9tYWMvUmVtb3RlTGF5 ZXJCYWNraW5nU3RvcmUubW0gYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvbWFjL1JlbW90ZUxheWVy QmFja2luZ1N0b3JlLm1tCmluZGV4IDQ4OWVhZjYuLmJmOGIwNTkgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL1NoYXJlZC9tYWMvUmVtb3RlTGF5ZXJCYWNraW5nU3RvcmUubW0KKysrIGIvU291 cmNlL1dlYktpdDIvU2hhcmVkL21hYy9SZW1vdGVMYXllckJhY2tpbmdTdG9yZS5tbQpAQCAtMzU0 LDEyICszNTQsMTEgQEAgdm9pZCBSZW1vdGVMYXllckJhY2tpbmdTdG9yZTo6YXBwbHlCYWNraW5n U3RvcmVUb0xheWVyKENBTGF5ZXIgKmxheWVyKQogICAgIGxheWVyLmNvbnRlbnRzID0gKGlkKW1f ZnJvbnRCdWZmZXItPm1ha2VDR0ltYWdlQ29weSgpLmdldCgpOwogfQogCi12b2lkIFJlbW90ZUxh eWVyQmFja2luZ1N0b3JlOjpmbHVzaCgpCitSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPiBSZW1vdGVM YXllckJhY2tpbmdTdG9yZTo6dGFrZUZyb250Q29udGV4dFBlbmRpbmdGbHVzaCgpCiB7Ci0gICAg aWYgKG1fZnJvbnRDb250ZXh0UGVuZGluZ0ZsdXNoKSB7Ci0gICAgICAgIENHQ29udGV4dEZsdXNo KG1fZnJvbnRDb250ZXh0UGVuZGluZ0ZsdXNoLmdldCgpKTsKLSAgICAgICAgbV9mcm9udENvbnRl eHRQZW5kaW5nRmx1c2ggPSBudWxscHRyOwotICAgIH0KKyAgICBSZXRhaW5QdHI8Q0dDb250ZXh0 UmVmPiBmcm9udENvbnRleHRQZW5kaW5nRmx1c2ggPSBtX2Zyb250Q29udGV4dFBlbmRpbmdGbHVz aDsKKyAgICBtX2Zyb250Q29udGV4dFBlbmRpbmdGbHVzaCA9IG51bGxwdHI7CisgICAgcmV0dXJu IGZyb250Q29udGV4dFBlbmRpbmdGbHVzaDsKIH0KIAogI2lmIFVTRShJT1NVUkZBQ0UpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvbWFjL1JlbW90ZUxheWVy VHJlZURyYXdpbmdBcmVhLmggYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvbWFj L1JlbW90ZUxheWVyVHJlZURyYXdpbmdBcmVhLmgKaW5kZXggMTQxMzQwZC4uYTdiMmY5ZSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL21hYy9SZW1vdGVMYXll clRyZWVEcmF3aW5nQXJlYS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFn ZS9tYWMvUmVtb3RlTGF5ZXJUcmVlRHJhd2luZ0FyZWEuaApAQCAtMzAsMTIgKzMwLDE4IEBACiAj aW5jbHVkZSAiR3JhcGhpY3NMYXllckNBUmVtb3RlLmgiCiAjaW5jbHVkZSA8V2ViQ29yZS9HcmFw aGljc0xheWVyQ2xpZW50Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9UaW1lci5oPgorI2luY2x1ZGUg PGF0b21pYz4KKyNpbmNsdWRlIDxkaXNwYXRjaC9kaXNwYXRjaC5oPgogI2luY2x1ZGUgPHd0Zi9I YXNoTWFwLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGNsYXNzIFBsYXRmb3JtQ0FMYXllcjsK IH0KIAorbmFtZXNwYWNlIElQQyB7CitjbGFzcyBNZXNzYWdlRW5jb2RlcjsKK30KKwogbmFtZXNw YWNlIFdlYktpdCB7CiAKIGNsYXNzIFJlbW90ZUxheWVyVHJlZUNvbnRleHQ7CkBAIC05Niw2ICsx MDIsMjIgQEAgcHJpdmF0ZToKIAogICAgIFdlYkNvcmU6OlRpbGVkQmFja2luZyogbWFpbkZyYW1l VGlsZWRCYWNraW5nKCkgY29uc3Q7CiAKKyAgICBjbGFzcyBCYWNraW5nU3RvcmVGbHVzaGVyIDog cHVibGljIFRocmVhZFNhZmVSZWZDb3VudGVkPEJhY2tpbmdTdG9yZUZsdXNoZXI+IHsKKyAgICBw dWJsaWM6CisgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPEJhY2tpbmdTdG9yZUZsdXNoZXI+IGNy ZWF0ZShJUEM6OkNvbm5lY3Rpb24qLCBzdGQ6OnVuaXF1ZV9wdHI8SVBDOjpNZXNzYWdlRW5jb2Rl cj4sIFZlY3RvcjxSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPj4pOworICAgICAgICBCYWNraW5nU3Rv cmVGbHVzaGVyKElQQzo6Q29ubmVjdGlvbiosIHN0ZDo6dW5pcXVlX3B0cjxJUEM6Ok1lc3NhZ2VF bmNvZGVyPiwgVmVjdG9yPFJldGFpblB0cjxDR0NvbnRleHRSZWY+Pik7CisKKyAgICAgICAgdm9p ZCBmbHVzaCgpOworICAgICAgICBib29sIGhhc0ZsdXNoZWQoKSBjb25zdCB7IHJldHVybiBtX2hh c0ZsdXNoZWQ7IH0KKworICAgIHByaXZhdGU6CisgICAgICAgIFJlZlB0cjxJUEM6OkNvbm5lY3Rp b24+IG1fY29ubmVjdGlvbjsKKyAgICAgICAgc3RkOjp1bmlxdWVfcHRyPElQQzo6TWVzc2FnZUVu Y29kZXI+IG1fY29tbWl0RW5jb2RlcjsKKyAgICAgICAgVmVjdG9yPFJldGFpblB0cjxDR0NvbnRl eHRSZWY+PiBtX2NvbnRleHRzVG9GbHVzaDsKKworICAgICAgICBzdGQ6OmF0b21pYzxib29sPiBt X2hhc0ZsdXNoZWQ7CisgICAgfTsKKwogICAgIHN0ZDo6dW5pcXVlX3B0cjxSZW1vdGVMYXllclRy ZWVDb250ZXh0PiBtX3JlbW90ZUxheWVyVHJlZUNvbnRleHQ7CiAgICAgc3RkOjp1bmlxdWVfcHRy PFdlYkNvcmU6OkdyYXBoaWNzTGF5ZXI+IG1fcm9vdExheWVyOwogCkBAIC0xMTAsNiArMTMyLDkg QEAgcHJpdmF0ZToKIAogICAgIGJvb2wgbV93YWl0aW5nRm9yQmFja2luZ1N0b3JlU3dhcDsKICAg ICBib29sIG1faGFkRmx1c2hEZWZlcnJlZFdoaWxlV2FpdGluZ0ZvckJhY2tpbmdTdG9yZVN3YXA7 CisKKyAgICBkaXNwYXRjaF9xdWV1ZV90IG1fY29tbWl0UXVldWU7CisgICAgUmVmUHRyPEJhY2tp bmdTdG9yZUZsdXNoZXI+IG1fcGVuZGluZ0JhY2tpbmdTdG9yZUZsdXNoZXI7CiB9OwogCiBEUkFX SU5HX0FSRUFfVFlQRV9DQVNUUyhSZW1vdGVMYXllclRyZWVEcmF3aW5nQXJlYSwgdHlwZSgpID09 IERyYXdpbmdBcmVhVHlwZVJlbW90ZUxheWVyVHJlZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvbWFjL1JlbW90ZUxheWVyVHJlZURyYXdpbmdBcmVhLm1t IGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL21hYy9SZW1vdGVMYXllclRyZWVE cmF3aW5nQXJlYS5tbQppbmRleCA5OGRjOWIwLi5iNzY2MzM1IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvbWFjL1JlbW90ZUxheWVyVHJlZURyYXdpbmdBcmVh Lm1tCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9tYWMvUmVtb3RlTGF5 ZXJUcmVlRHJhd2luZ0FyZWEubW0KQEAgLTM1LDYgKzM1LDcgQEAKICNpbXBvcnQgIlJlbW90ZVNj cm9sbGluZ0Nvb3JkaW5hdG9yLmgiCiAjaW1wb3J0ICJSZW1vdGVTY3JvbGxpbmdDb29yZGluYXRv clRyYW5zYWN0aW9uLmgiCiAjaW1wb3J0ICJXZWJQYWdlLmgiCisjaW1wb3J0ICJXZWJQcm9jZXNz LmgiCiAjaW1wb3J0IDxXZWJDb3JlL0ZyYW1lLmg+CiAjaW1wb3J0IDxXZWJDb3JlL0ZyYW1lVmll dy5oPgogI2ltcG9ydCA8V2ViQ29yZS9NYWluRnJhbWUuaD4KQEAgLTY0LDEwICs2NSwxMyBAQCBS ZW1vdGVMYXllclRyZWVEcmF3aW5nQXJlYTo6UmVtb3RlTGF5ZXJUcmVlRHJhd2luZ0FyZWEoV2Vi UGFnZSogd2ViUGFnZSwgY29uc3QgVwogI2lmIFBMQVRGT1JNKElPUykKICAgICB3ZWJQYWdlLT5j b3JlUGFnZSgpLT5zZXR0aW5ncygpLnNldERlbGVnYXRlc1BhZ2VTY2FsaW5nKHRydWUpOwogI2Vu ZGlmCisKKyAgICBtX2NvbW1pdFF1ZXVlID0gZGlzcGF0Y2hfcXVldWVfY3JlYXRlKCJjb20uYXBw bGUuV2ViS2l0LldlYkNvbnRlbnQuUmVtb3RlTGF5ZXJUcmVlRHJhd2luZ0FyZWFDb21taXRRdWV1 ZSIsIG51bGxwdHIpOwogfQogCiBSZW1vdGVMYXllclRyZWVEcmF3aW5nQXJlYTo6flJlbW90ZUxh eWVyVHJlZURyYXdpbmdBcmVhKCkKIHsKKyAgICBkaXNwYXRjaF9yZWxlYXNlKG1fY29tbWl0UXVl dWUpOwogfQogCiB2b2lkIFJlbW90ZUxheWVyVHJlZURyYXdpbmdBcmVhOjpzZXROZWVkc0Rpc3Bs YXkoKQpAQCAtMjIzLDE3ICsyMjcsNiBAQCB2b2lkIFJlbW90ZUxheWVyVHJlZURyYXdpbmdBcmVh OjpsYXllckZsdXNoVGltZXJGaXJlZChXZWJDb3JlOjpUaW1lcjxSZW1vdGVMYXllcgogICAgIGZs dXNoTGF5ZXJzKCk7CiB9CiAKLXN0YXRpYyB2b2lkIGZsdXNoQmFja2luZ1N0b3JlQ2hhbmdlc0lu VHJhbnNhY3Rpb24oUmVtb3RlTGF5ZXJUcmVlVHJhbnNhY3Rpb24mIHRyYW5zYWN0aW9uKQotewot ICAgIGZvciAoUmVmUHRyPFBsYXRmb3JtQ0FMYXllclJlbW90ZT4gbGF5ZXIgOiB0cmFuc2FjdGlv bi5jaGFuZ2VkTGF5ZXJzKCkpIHsKLSAgICAgICAgaWYgKCFsYXllci0+cHJvcGVydGllcygpLmNo YW5nZWRQcm9wZXJ0aWVzICYgUmVtb3RlTGF5ZXJUcmVlVHJhbnNhY3Rpb246OkJhY2tpbmdTdG9y ZUNoYW5nZWQpCi0gICAgICAgICAgICByZXR1cm47Ci0KLSAgICAgICAgaWYgKFJlbW90ZUxheWVy QmFja2luZ1N0b3JlKiBiYWNraW5nU3RvcmUgPSBsYXllci0+cHJvcGVydGllcygpLmJhY2tpbmdT dG9yZS5nZXQoKSkKLSAgICAgICAgICAgIGJhY2tpbmdTdG9yZS0+Zmx1c2goKTsKLSAgICB9Ci19 Ci0KIHZvaWQgUmVtb3RlTGF5ZXJUcmVlRHJhd2luZ0FyZWE6OmZsdXNoTGF5ZXJzKCkKIHsKICAg ICBpZiAoIW1fcm9vdExheWVyKQpAQCAtMjQ5LDYgKzI0Miw4IEBAIHZvaWQgUmVtb3RlTGF5ZXJU cmVlRHJhd2luZ0FyZWE6OmZsdXNoTGF5ZXJzKCkKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAor ICAgIFJFTEVBU0VfQVNTRVJUKCFtX3BlbmRpbmdCYWNraW5nU3RvcmVGbHVzaGVyIHx8IG1fcGVu ZGluZ0JhY2tpbmdTdG9yZUZsdXNoZXItPmhhc0ZsdXNoZWQoKSk7CisKICAgICBtX3dlYlBhZ2Ut PmxheW91dElmTmVlZGVkKCk7CiAKICAgICBGbG9hdFJlY3QgdmlzaWJsZVJlY3QoRmxvYXRQb2lu dCgpLCBtX3ZpZXdTaXplKTsKQEAgLTI2OCwyMSArMjYzLDM1IEBAIHZvaWQgUmVtb3RlTGF5ZXJU cmVlRHJhd2luZ0FyZWE6OmZsdXNoTGF5ZXJzKCkKICAgICAgICAgdG9SZW1vdGVTY3JvbGxpbmdD b29yZGluYXRvcihtX3dlYlBhZ2UtPnNjcm9sbGluZ0Nvb3JkaW5hdG9yKCkpLT5idWlsZFRyYW5z YWN0aW9uKHNjcm9sbGluZ1RyYW5zYWN0aW9uKTsKICNlbmRpZgogCi0gICAgLy8gRklYTUU6IE1v dmUgZmx1c2hpbmcgYmFja2luZyBzdG9yZSBhbmQgc2VuZGluZyBDb21taXRMYXllclRyZWUgb250 byBhIGJhY2tncm91bmQgdGhyZWFkLgotICAgIGZsdXNoQmFja2luZ1N0b3JlQ2hhbmdlc0luVHJh bnNhY3Rpb24obGF5ZXJUcmFuc2FjdGlvbik7Ci0KICAgICBtX3dhaXRpbmdGb3JCYWNraW5nU3Rv cmVTd2FwID0gdHJ1ZTsKLSAgICBtX3dlYlBhZ2UtPnNlbmQoTWVzc2FnZXM6OlJlbW90ZUxheWVy VHJlZURyYXdpbmdBcmVhUHJveHk6OkNvbW1pdExheWVyVHJlZShsYXllclRyYW5zYWN0aW9uLCBz Y3JvbGxpbmdUcmFuc2FjdGlvbikpOworCisgICAgTWVzc2FnZXM6OlJlbW90ZUxheWVyVHJlZURy YXdpbmdBcmVhUHJveHk6OkNvbW1pdExheWVyVHJlZSBtZXNzYWdlKGxheWVyVHJhbnNhY3Rpb24s IHNjcm9sbGluZ1RyYW5zYWN0aW9uKTsKKyAgICBhdXRvIGNvbW1pdEVuY29kZXIgPSBzdGQ6Om1h a2VfdW5pcXVlPElQQzo6TWVzc2FnZUVuY29kZXI+KE1lc3NhZ2VzOjpSZW1vdGVMYXllclRyZWVE cmF3aW5nQXJlYVByb3h5OjpDb21taXRMYXllclRyZWU6OnJlY2VpdmVyTmFtZSgpLCBNZXNzYWdl czo6UmVtb3RlTGF5ZXJUcmVlRHJhd2luZ0FyZWFQcm94eTo6Q29tbWl0TGF5ZXJUcmVlOjpuYW1l KCksIG1fd2ViUGFnZS0+cGFnZUlEKCkpOworICAgIGNvbW1pdEVuY29kZXItPmVuY29kZShtZXNz YWdlLmFyZ3VtZW50cygpKTsKIAogICAgIGJvb2wgaGFkQW55Q2hhbmdlZEJhY2tpbmdTdG9yZSA9 IGZhbHNlOworICAgIFZlY3RvcjxSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPj4gY29udGV4dHNUb0Zs dXNoOwogICAgIGZvciAoYXV0byYgbGF5ZXIgOiBsYXllclRyYW5zYWN0aW9uLmNoYW5nZWRMYXll cnMoKSkgewotICAgICAgICBpZiAobGF5ZXItPnByb3BlcnRpZXMoKS5jaGFuZ2VkUHJvcGVydGll cyAmIFJlbW90ZUxheWVyVHJlZVRyYW5zYWN0aW9uOjpMYXllckNoYW5nZXM6OkJhY2tpbmdTdG9y ZUNoYW5nZWQpCisgICAgICAgIGlmIChsYXllci0+cHJvcGVydGllcygpLmNoYW5nZWRQcm9wZXJ0 aWVzICYgUmVtb3RlTGF5ZXJUcmVlVHJhbnNhY3Rpb246OkxheWVyQ2hhbmdlczo6QmFja2luZ1N0 b3JlQ2hhbmdlZCkgewogICAgICAgICAgICAgaGFkQW55Q2hhbmdlZEJhY2tpbmdTdG9yZSA9IHRy dWU7CisKKyAgICAgICAgICAgIFJldGFpblB0cjxDR0NvbnRleHRSZWY+IGNvbnRleHRQZW5kaW5n Rmx1c2ggPSBsYXllci0+cHJvcGVydGllcygpLmJhY2tpbmdTdG9yZS0+dGFrZUZyb250Q29udGV4 dFBlbmRpbmdGbHVzaCgpOworICAgICAgICAgICAgaWYgKGNvbnRleHRQZW5kaW5nRmx1c2gpCisg ICAgICAgICAgICAgICAgY29udGV4dHNUb0ZsdXNoLmFwcGVuZChjb250ZXh0UGVuZGluZ0ZsdXNo KTsKKyAgICAgICAgfQorCiAgICAgICAgIGxheWVyLT5kaWRDb21taXQoKTsKICAgICB9CiAKICAg ICBpZiAoaGFkQW55Q2hhbmdlZEJhY2tpbmdTdG9yZSkKICAgICAgICAgbV9yZW1vdGVMYXllclRy ZWVDb250ZXh0LT5iYWNraW5nU3RvcmVDb2xsZWN0aW9uKCkuc2NoZWR1bGVQdXJnZWFiaWxpdHlU aW1lcigpOworCisgICAgUmVmUHRyPEJhY2tpbmdTdG9yZUZsdXNoZXI+IGJhY2tpbmdTdG9yZUZs dXNoZXIgPSBCYWNraW5nU3RvcmVGbHVzaGVyOjpjcmVhdGUoV2ViUHJvY2Vzczo6c2hhcmVkKCku cGFyZW50UHJvY2Vzc0Nvbm5lY3Rpb24oKSwgc3RkOjptb3ZlKGNvbW1pdEVuY29kZXIpLCBjb250 ZXh0c1RvRmx1c2gpOworICAgIG1fcGVuZGluZ0JhY2tpbmdTdG9yZUZsdXNoZXIgPSBiYWNraW5n U3RvcmVGbHVzaGVyOworCisgICAgZGlzcGF0Y2hfYXN5bmMobV9jb21taXRRdWV1ZSwgW2JhY2tp bmdTdG9yZUZsdXNoZXJdKCl7CisgICAgICAgIGJhY2tpbmdTdG9yZUZsdXNoZXItPmZsdXNoKCk7 CisgICAgfSk7CiB9CiAKIHZvaWQgUmVtb3RlTGF5ZXJUcmVlRHJhd2luZ0FyZWE6OmRpZFVwZGF0 ZSgpCkBAIC0zMDgsNCArMzE3LDI2IEBAIHZvaWQgUmVtb3RlTGF5ZXJUcmVlRHJhd2luZ0FyZWE6 Om1haW5GcmFtZUNvbnRlbnRTaXplQ2hhbmdlZChjb25zdCBJbnRTaXplJiBjb250CiAgICAgbV93 ZWJQYWdlLT5wYWdlT3ZlcmxheUNvbnRyb2xsZXIoKS5kaWRDaGFuZ2VEb2N1bWVudFNpemUoKTsK IH0KIAorUGFzc1JlZlB0cjxSZW1vdGVMYXllclRyZWVEcmF3aW5nQXJlYTo6QmFja2luZ1N0b3Jl Rmx1c2hlcj4gUmVtb3RlTGF5ZXJUcmVlRHJhd2luZ0FyZWE6OkJhY2tpbmdTdG9yZUZsdXNoZXI6 OmNyZWF0ZShJUEM6OkNvbm5lY3Rpb24qIGNvbm5lY3Rpb24sIHN0ZDo6dW5pcXVlX3B0cjxJUEM6 Ok1lc3NhZ2VFbmNvZGVyPiBlbmNvZGVyLCBWZWN0b3I8UmV0YWluUHRyPENHQ29udGV4dFJlZj4+ IGNvbnRleHRzVG9GbHVzaCkKK3sKKyAgICByZXR1cm4gYWRvcHRSZWYobmV3IFJlbW90ZUxheWVy VHJlZURyYXdpbmdBcmVhOjpCYWNraW5nU3RvcmVGbHVzaGVyKGNvbm5lY3Rpb24sIHN0ZDo6bW92 ZShlbmNvZGVyKSwgY29udGV4dHNUb0ZsdXNoKSk7Cit9CisKK1JlbW90ZUxheWVyVHJlZURyYXdp bmdBcmVhOjpCYWNraW5nU3RvcmVGbHVzaGVyOjpCYWNraW5nU3RvcmVGbHVzaGVyKElQQzo6Q29u bmVjdGlvbiogY29ubmVjdGlvbiwgc3RkOjp1bmlxdWVfcHRyPElQQzo6TWVzc2FnZUVuY29kZXI+ IGVuY29kZXIsIFZlY3RvcjxSZXRhaW5QdHI8Q0dDb250ZXh0UmVmPj4gY29udGV4dHNUb0ZsdXNo KQorICAgIDogbV9jb25uZWN0aW9uKGNvbm5lY3Rpb24pCisgICAgLCBtX2NvbW1pdEVuY29kZXIo c3RkOjptb3ZlKGVuY29kZXIpKQorICAgICwgbV9jb250ZXh0c1RvRmx1c2goY29udGV4dHNUb0Zs dXNoKQorICAgICwgbV9oYXNGbHVzaGVkKGZhbHNlKQoreworfQorCit2b2lkIFJlbW90ZUxheWVy VHJlZURyYXdpbmdBcmVhOjpCYWNraW5nU3RvcmVGbHVzaGVyOjpmbHVzaCgpCit7CisgICAgZm9y IChhdXRvJiBjb250ZXh0IDogbV9jb250ZXh0c1RvRmx1c2gpCisgICAgICAgIENHQ29udGV4dEZs dXNoKGNvbnRleHQuZ2V0KCkpOworCisgICAgbV9jb25uZWN0aW9uLT5zZW5kTWVzc2FnZShzdGQ6 Om1vdmUobV9jb21taXRFbmNvZGVyKSk7CisgICAgbV9oYXNGbHVzaGVkID0gdHJ1ZTsKK30KKwog fSAvLyBuYW1lc3BhY2UgV2ViS2l0Cg==