35943 2010-03-09 13:48:05 -0800 Make Document::postTask to use a single queue of tasks, to fire them in order 2011-04-28 09:22:25 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED P2 Normal --- 34726 59705 1 dimich dimich ap atwilson dumi levin michaeln oldest_to_newest 197754 0 dimich 2010-03-09 13:48:05 -0800 Description of the original problem, from Dumitru Daniliuc: "for the DB code to work, we sometimes need to guarantee that tasks run in the order in which their posted. the example we have is: 1. main thread posts task_1 to itself. 2. main thread posts task_2 to the DB thread. 3. task_2 runs on the DB thread and posts task_3 to the main thread. without the changes i made to Document::postTask(), task_3 would be executed before task_1 on the main thread on all mac platforms, 100% of the time." That happens because when called on the main thread, postTask would use one-shot timer (and timer queue) while if posted from another thread, it'll use callOnMainThread with it's own queue - so the tasks may execute in a different order then they are posted. The fix would be to always use the single queue and callOnMainThread() to schedule tasks. This fix was attempted (bug 34726) and caused a regression (bug 35819). The fix for the starvation issue was discussed in https://lists.webkit.org/pipermail/webkit-dev/2010-March/011845.html. Patch is coming. 197785 1 50353 dimich 2010-03-09 14:44:36 -0800 Created attachment 50353 Patch. 197788 2 50353 darin 2010-03-09 14:48:50 -0800 Comment on attachment 50353 Patch. > +static void timerFired(CFRunLoopTimerRef timer, void*) > +{ > + CFRelease(timer); > + WTF::dispatchFunctionsFromMainThread(); > +} > + > +void postTimer() > +{ > + ASSERT(isMainThread()); > +#if USE(WEB_THREAD) > + ASSERT(webThread == [NSThread currentThread]); > +#endif > + > + CFRunLoopAddTimer(CFRunLoopGetCurrent(), CFRunLoopTimerCreate(0, 0, 0, 0, 0, timerFired, 0), kCFRunLoopCommonModes); > +} I suggest writing this with a global variable to make sure we don't keep making a new CFRunLoopTimer object each time this is called. With a global variable we could coalesce multiple calls. The global could just be a boolean. (Unless some other level is already coalescing. I don't think so.) Is the assertion correct? Maybe the isMainThread assertion belongs inside the #else of the USE(WEB_THREAD)? 197802 3 50353 ap 2010-03-09 15:17:50 -0800 Comment on attachment 50353 Patch. With this patch, a task posted from main thread may end up being delivered under a modal dialog (if scheduleDispatchFunctionsOnMainThread has been already called to deliver a message from a worker). This wasn't the case previously Please convince me that I'm wrong, and set back to r?. 197804 4 dimich 2010-03-09 15:23:15 -0800 (In reply to comment #2) > I suggest writing this with a global variable to make sure we don't keep making > a new CFRunLoopTimer object each time this is called. With a global variable we > could coalesce multiple calls. The global could just be a boolean. (Unless some > other level is already coalescing. I don't think so.) Will do, the higher level (see callOnMainThread()) is trying to avoid unnecessary posts, but it does not do it 100% (duplicating posts can be done from dispatchFunctionsFromMainThread when it exits on timeout). The bool is cheap so it's a good thing to add. > Is the assertion correct? Maybe the isMainThread assertion belongs inside the > #else of the USE(WEB_THREAD)? It is correct to check for IsMainThread because in this case WTF's idea of main thread is the same as webThread (http://trac.webkit.org/changeset/52046) The patch also broke http/tests/appcache/top-frame-2.html, so I'll upload updated patch when I figure that out as well. 197811 5 dimich 2010-03-09 15:35:17 -0800 (In reply to comment #3) > (From update of attachment 50353 [details]) > With this patch, a task posted from main thread may end up being delivered > under a modal dialog (if scheduleDispatchFunctionsOnMainThread has been already > called to deliver a message from a worker). This wasn't the case previously > > Please convince me that I'm wrong, and set back to r?. Wasn't it always possible? Chrome::runModal() enables the timers back under modal UI (TimerBase::fireTimersInNestedEventLoop()). I believe it was done for showModalDialog in http://trac.webkit.org/changeset/25103 197813 6 50353 dimich 2010-03-09 15:36:18 -0800 Comment on attachment 50353 Patch. Removing flags from obsolete patch. 197822 7 ap 2010-03-09 15:54:41 -0800 Yes, I was wrong. 198246 8 dimich 2010-03-10 11:39:28 -0800 The test LayoutTests/http/tests/appcache/top-frame-2.html now fails (at least on my machine) because it depends on the order of events fired in JS: 1. "checking" event from ApplicationCache (fired via Document::postTask()) 2. "message" event from window.postMessage (fired via one-shot timer) Before, those events were using the same queue of timers, while with this change they would use 'different' ones - so now the event from cache comes right after "onmessage" and therefore is missing from the log because "onmessage" handler stops the test. Although it is a bit scary that the order of visible JS events would change, since ApplicationCache seems to be the only component using postTask from the main thread at the moment, it is unlikely that many users of one-shot timers would be affected beyond ApplicationCache (other users of postTask are Database and Workers, both from other threads). For now, I'd think that it's ok to go ahead with this change since it at least orders tasks posted by postTask(), and change the test. ApplicationCache is not yet widely used so it is not very likely that we'll break much, and it'd be good to fix postTask while it's not used wider then now. Obviously, I'd watch for possible regressions after the change... Does it look like reasonable risk? 198264 9 dimich 2010-03-10 12:32:33 -0800 Thanks to Alexey Proskuryakov for suggestion to look at task queue spec of HTML5 to figure out what it says about ordering of events. Event Loop in HTML5 (http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#event-loop) defines that there are "task sources" and that all tasks that belong to a single source should be executed in order, while the tasks with different sources can be executed as if they were placed in separate queues (the order of picking queues is said to be "any"). The Application Cache events are specified to be from a "networking task source" http://www.whatwg.org/specs/web-apps/current-work/multipage/offline.html#pending-application-cache-download-process-tasks). The window.postMessage tasks are defined to be from a "posted message task source" (http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#posting-messages) The XHR events triggering postMessage in the test are from "XMLHttpRequest task source" (http://dev.w3.org/2006/webapi/XMLHttpRequest-2/#task-sources) So from HTML5 perspective, it seems the events in question can come in any order. Unfortunately, FF behavior is inconsistent: 3.5.8 passes the test as with this patch, while 3.6 actually fails it. 198269 10 michaeln 2010-03-10 12:45:53 -0800 (In reply to comment #9) > Thanks to Alexey Proskuryakov for suggestion to look at task queue spec of > HTML5 to figure out what it says about ordering of events. > > So from HTML5 perspective, it seems the events in question can come in any > order. I think its reasonable to alter the expectation for the appcache test to not be dependent on the relative ordering of messages received from newly loaded subframes vs appcache events. The top-frame-2 test could signal completion after both 'checking' and 'message' have been received without regard for their order. Actually you can see https://bugs.webkit.org/show_bug.cgi?id=32047 for a patch to the top-frame-2 test which does that alteration. I think changes like that could make the appcache test suite more of a test for spec compliance than a test of webkit's particular impl (which considering chrome has a different impl is of interest to me). 198324 11 50434 dimich 2010-03-10 13:56:20 -0800 Created attachment 50434 patch with updated App Cache test. I think the discussion here, in bug 32047 and the current AC spec seem to converge on treating the AppCache events as async and able to come in any order related to postMessage event in this test. I've updated the test so it is not dependent on the order of tasks, and waits for 3 signals in any order: AC events 'checking' and 'noupdate' and a message from the subframe. Also test prints order of all events if loaded in browser manually. Correction to my above statement: FF 3.6 actually behaves exactly as WebKit will after this patch, wrt the set and order of those events. I didn't clear the app cache of FF while doing experiments... 198377 12 50434 darin 2010-03-10 15:20:09 -0800 Comment on attachment 50434 patch with updated App Cache test. > + if (!isTimerPosted) { > + isTimerPosted = true; > + CFRunLoopAddTimer(CFRunLoopGetCurrent(), CFRunLoopTimerCreate(0, 0, 0, 0, 0, timerFired, 0), kCFRunLoopCommonModes); > + } I normally write these as early returns instead of nesting the code. > > Is the assertion correct? Maybe the isMainThread assertion belongs inside the > > #else of the USE(WEB_THREAD)? > > It is correct to check for IsMainThread because in this case WTF's idea of main > thread is the same as webThread (http://trac.webkit.org/changeset/52046) If that is so, then why do we need the WEB_THREAD assertion at all? 198404 13 dimich 2010-03-10 16:10:50 -0800 (In reply to comment #12) > (From update of attachment 50434 [details]) > > + if (!isTimerPosted) { > > + isTimerPosted = true; > > + CFRunLoopAddTimer(CFRunLoopGetCurrent(), CFRunLoopTimerCreate(0, 0, 0, 0, 0, timerFired, 0), kCFRunLoopCommonModes); > > + } > > I normally write these as early returns instead of nesting the code. Fixed. > > > Is the assertion correct? Maybe the isMainThread assertion belongs inside the > > > #else of the USE(WEB_THREAD)? > > > > It is correct to check for IsMainThread because in this case WTF's idea of main > > thread is the same as webThread (http://trac.webkit.org/changeset/52046) > > If that is so, then why do we need the WEB_THREAD assertion at all? Right. I was (a bit paranoidly) trying to verify that isMainThread and webThread are the same but this check does not really belong here and does not add clarity, so it is removed. Landed: http://trac.webkit.org/changeset/55816 50353 2010-03-09 14:44:36 -0800 2010-03-10 13:56:20 -0800 Patch. patch.txt text/plain 4801 dimich ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCA5MjdmMjE3Li4wNmE3YWMxIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkg QEAKKzIwMTAtMDMtMDkgIERtaXRyeSBUaXRvdiAgPGRpbWljaEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFrZSBEb2N1bWVu dDo6cG9zdFRhc2sgdG8gdXNlIGEgc2luZ2xlIHF1ZXVlIG9mIHRhc2tzLCB0byBmaXJlIHRoZW0g aW4gb3JkZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTM1OTQzCisKKyAgICAgICAgVGhlIHBhdGNoIHVzZXMgQ0ZSdW5Mb29wVGltZXIgdG8gc2NoZWR1 bGUgZXhlY3V0aW9uIG9mIHRhc2tzIGluc3RlYWQgb2YgcGVyZm9ybVNlbGVjdG9yT25NYWluVGhy ZWFkIHdoaWNoIGFwcGFyZW50bHkgY2FuIHN0YXJ2ZSBvdGhlciBldmVudCBzb3VyY2VzLgorICAg ICAgICBUaGUgdGltZXIgaXMgdXNlZCB3aGVuIHRoZSBzY2hlZHVsZSByZXF1ZXN0IGlzIGNvbWlu ZyBvbiB0aGUgbWFpbiB0aHJlYWQgaXRzZWxmLiBUaGlzIGhhcHBlbnMgd2hlbiB0aGUgdGFzayBp cyBwb3N0ZWQgb24gdGhlIG1haW4gdGhyZWFkIG9yCisgICAgICAgIHdoZW4gdG9vIG1hbnkgdGFz a3MgYXJlIHBvc3RlZCBhbmQgdGhlIHF1ZXVlIGRvZXMgJ3N0b3AgYW5kIHJlLXNjaGVkdWxlJyB0 byBtYWtlIHN1cmUgcnVuIGxvb3AgaGFzIGEgY2hhbmNlIHRvIGV4ZWN1dGUgb3RoZXIgZXZlbnRz LgorCisgICAgICAgICogd3RmL21hYy9NYWluVGhyZWFkTWFjLm1tOgorICAgICAgICAoV1RGOjp0 aW1lckZpcmVkKToKKyAgICAgICAgKFdURjo6cG9zdFRpbWVyKToKKyAgICAgICAgKFdURjo6c2No ZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFpblRocmVhZCk6IFVzZSB0aW1lciBwb3N0ZWQgdG8g dGhlIGN1cnJlbnQgUnVuTG9vcCBpZiBzY2hlZHVsaW5nIHRoZSB0YXNrIGV4ZWN1dGlvbiB3aGls ZSBvbiB0aGUgbWFpbiB0aHJlYWQuCisKIDIwMTAtMDMtMDkgIEdhYm9yIExva2kgIDxsb2tpQHdl YmtpdC5vcmc+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgTWFjaWVqIFN0YWNob3dpYWsu CmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvbWFjL01haW5UaHJlYWRNYWMubW0gYi9K YXZhU2NyaXB0Q29yZS93dGYvbWFjL01haW5UaHJlYWRNYWMubW0KaW5kZXggMGRkZDVmNi4uYmU2 YTkzNiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL21hYy9NYWluVGhyZWFkTWFjLm1t CisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi9tYWMvTWFpblRocmVhZE1hYy5tbQpAQCAtMjksOCAr MjksMTAgQEAKICNpbXBvcnQgImNvbmZpZy5oIgogI2ltcG9ydCAiTWFpblRocmVhZC5oIgogCisj aW1wb3J0IDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2ltcG9ydCA8Rm91bmRh dGlvbi9OU1RocmVhZC5oPgogI2ltcG9ydCA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbXBvcnQgPHd0 Zi9UaHJlYWRpbmcuaD4KIAogQGludGVyZmFjZSBXVEZNYWluVGhyZWFkQ2FsbGVyIDogTlNPYmpl Y3QgewogfQpAQCAtNjMsOSArNjUsMzIgQEAgdm9pZCBpbml0aWFsaXplTWFpblRocmVhZFBsYXRm b3JtKCkKICNlbmRpZgogfQogCitzdGF0aWMgdm9pZCB0aW1lckZpcmVkKENGUnVuTG9vcFRpbWVy UmVmIHRpbWVyLCB2b2lkKikKK3sKKyAgICBDRlJlbGVhc2UodGltZXIpOworICAgIFdURjo6ZGlz cGF0Y2hGdW5jdGlvbnNGcm9tTWFpblRocmVhZCgpOworfQorCit2b2lkIHBvc3RUaW1lcigpCit7 CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyNpZiBVU0UoV0VCX1RIUkVBRCkKKyAgICBB U1NFUlQod2ViVGhyZWFkID09IFtOU1RocmVhZCBjdXJyZW50VGhyZWFkXSk7CisjZW5kaWYKKwor ICAgIENGUnVuTG9vcEFkZFRpbWVyKENGUnVuTG9vcEdldEN1cnJlbnQoKSwgQ0ZSdW5Mb29wVGlt ZXJDcmVhdGUoMCwgMCwgMCwgMCwgMCwgdGltZXJGaXJlZCwgMCksIGtDRlJ1bkxvb3BDb21tb25N b2Rlcyk7Cit9CisKKwogdm9pZCBzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhyZWFk KCkKIHsKICAgICBBU1NFUlQoc3RhdGljTWFpblRocmVhZENhbGxlcik7CisKKyAgICBpZiAoaXNN YWluVGhyZWFkKCkpIHsKKyAgICAgICAgcG9zdFRpbWVyKCk7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKICNpZiBVU0UoV0VCX1RIUkVBRCkKICAgICBbc3RhdGljTWFpblRocmVhZENhbGxlciBw ZXJmb3JtU2VsZWN0b3I6QHNlbGVjdG9yKGNhbGwpIG9uVGhyZWFkOndlYlRocmVhZCB3aXRoT2Jq ZWN0Om5pbCB3YWl0VW50aWxEb25lOk5PXTsKICNlbHNlCmRpZmYgLS1naXQgYS9XZWJDb3JlL0No YW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDMwNTViMjMuLjM4MDg5MWEgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTYgQEAKKzIwMTAtMDMtMDkgIERtaXRyeSBUaXRvdiAgPGRpbWljaEBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFrZSBE b2N1bWVudDo6cG9zdFRhc2sgdG8gdXNlIGEgc2luZ2xlIHF1ZXVlIG9mIHRhc2tzLCB0byBmaXJl IHRoZW0gaW4gb3JkZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTM1OTQzCisKKyAgICAgICAgVGVzdDogZXhpc3Rpbmcgd29ya2VyLWNsb25lcG9ydC5o dG1sIHdoaWNoIHdhcyBicm9rZW4gYnkgaW5pdGlhbCBwYXRjaCBpbiBodHRwOi8vdHJhYy53ZWJr aXQub3JnL2NoYW5nZXNldC81NTU5My4KKyAgICAgICAgQWRkaXRpb25hbCB0ZXN0IHdoaWNoIGlu ZGlyZWN0bHkgdmVyaWZpZXMgdGhlIG9yZGVyIG9mIGV4ZWN1dGlvbiB3aWxsIGNvbWUgYXMgcGFy dCBvZiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQ3MjYKKworICAg ICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6cG9z dFRhc2spOiBBbHdheXMgdXNlIHRoZSBzYW1lIHRhc2sgcXVldWUsIGluZGVwZW5kZW50IG9mIHdo YXQgdGhyZWFkIGlzIHBvc3RpbmcgdGhlIHRhc2suCisKIDIwMTAtMDMtMDkgIEJyYWR5IEVpZHNv biAgPGJlaWRzb25AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVy LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwIGIvV2ViQ29yZS9kb20vRG9j dW1lbnQuY3BwCmluZGV4IDc5YmZhOTcuLjQzYzg0MWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9t L0RvY3VtZW50LmNwcAorKysgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKQEAgLTQ2ODUsMjUg KzQ2ODUsNiBAQCB2b2lkIERvY3VtZW50OjpzY3JpcHRJbXBvcnRlZCh1bnNpZ25lZCBsb25nIGlk ZW50aWZpZXIsIGNvbnN0IFN0cmluZyYgc291cmNlU3RyaQogI2VuZGlmCiB9CiAKLWNsYXNzIFNj cmlwdEV4ZWN1dGlvbkNvbnRleHRUYXNrVGltZXIgOiBwdWJsaWMgVGltZXJCYXNlIHsKLXB1Ymxp YzoKLSAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0VGFza1RpbWVyKFBhc3NSZWZQdHI8RG9jdW1l bnQ+IGNvbnRleHQsIFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFz aykKLSAgICAgICAgOiBtX2NvbnRleHQoY29udGV4dCkKLSAgICAgICAgLCBtX3Rhc2sodGFzaykK LSAgICB7Ci0gICAgfQotCi1wcml2YXRlOgotICAgIHZpcnR1YWwgdm9pZCBmaXJlZCgpCi0gICAg ewotICAgICAgICBtX3Rhc2stPnBlcmZvcm1UYXNrKG1fY29udGV4dC5nZXQoKSk7Ci0gICAgICAg IGRlbGV0ZSB0aGlzOwotICAgIH0KLQotICAgIFJlZlB0cjxEb2N1bWVudD4gbV9jb250ZXh0Owot ICAgIE93blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiBtX3Rhc2s7Ci19OwotCiBz dHJ1Y3QgUGVyZm9ybVRhc2tDb250ZXh0IDogTm9uY29weWFibGUgewogICAgIFBlcmZvcm1UYXNr Q29udGV4dChQYXNzUmVmUHRyPERvY3VtZW50V2Vha1JlZmVyZW5jZT4gZG9jdW1lbnRSZWZlcmVu Y2UsIFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaykKICAgICAg ICAgOiBkb2N1bWVudFJlZmVyZW5jZShkb2N1bWVudFJlZmVyZW5jZSkKQEAgLTQ3MzAsMTIgKzQ3 MTEsNyBAQCBzdGF0aWMgdm9pZCBwZXJmb3JtVGFzayh2b2lkKiBjdHgpCiAKIHZvaWQgRG9jdW1l bnQ6OnBvc3RUYXNrKFBhc3NPd25QdHI8VGFzaz4gdGFzaykKIHsKLSAgICBpZiAoaXNNYWluVGhy ZWFkKCkpIHsKLSAgICAgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dFRhc2tUaW1lciogdGltZXIg PSBuZXcgU2NyaXB0RXhlY3V0aW9uQ29udGV4dFRhc2tUaW1lcihzdGF0aWNfY2FzdDxEb2N1bWVu dCo+KHRoaXMpLCB0YXNrKTsKLSAgICAgICAgdGltZXItPnN0YXJ0T25lU2hvdCgwKTsKLSAgICB9 IGVsc2UgewotICAgICAgICBjYWxsT25NYWluVGhyZWFkKHBlcmZvcm1UYXNrLCBuZXcgUGVyZm9y bVRhc2tDb250ZXh0KG1fd2Vha1JlZmVyZW5jZSwgdGFzaykpOwotICAgIH0KKyAgICBjYWxsT25N YWluVGhyZWFkKHBlcmZvcm1UYXNrLCBuZXcgUGVyZm9ybVRhc2tDb250ZXh0KG1fd2Vha1JlZmVy ZW5jZSwgdGFzaykpOwogfQogCiBFbGVtZW50KiBEb2N1bWVudDo6ZmluZEFuY2hvcihjb25zdCBT dHJpbmcmIG5hbWUpCg== 50434 2010-03-10 13:56:20 -0800 2010-03-10 15:20:09 -0800 patch with updated App Cache test. patch.txt text/plain 8475 dimich ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZyBiL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZwppbmRleCA5MjdmMjE3Li4wNmE3YWMxIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS9DaGFuZ2VMb2cKKysrIGIvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkg QEAKKzIwMTAtMDMtMDkgIERtaXRyeSBUaXRvdiAgPGRpbWljaEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFrZSBEb2N1bWVu dDo6cG9zdFRhc2sgdG8gdXNlIGEgc2luZ2xlIHF1ZXVlIG9mIHRhc2tzLCB0byBmaXJlIHRoZW0g aW4gb3JkZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTM1OTQzCisKKyAgICAgICAgVGhlIHBhdGNoIHVzZXMgQ0ZSdW5Mb29wVGltZXIgdG8gc2NoZWR1 bGUgZXhlY3V0aW9uIG9mIHRhc2tzIGluc3RlYWQgb2YgcGVyZm9ybVNlbGVjdG9yT25NYWluVGhy ZWFkIHdoaWNoIGFwcGFyZW50bHkgY2FuIHN0YXJ2ZSBvdGhlciBldmVudCBzb3VyY2VzLgorICAg ICAgICBUaGUgdGltZXIgaXMgdXNlZCB3aGVuIHRoZSBzY2hlZHVsZSByZXF1ZXN0IGlzIGNvbWlu ZyBvbiB0aGUgbWFpbiB0aHJlYWQgaXRzZWxmLiBUaGlzIGhhcHBlbnMgd2hlbiB0aGUgdGFzayBp cyBwb3N0ZWQgb24gdGhlIG1haW4gdGhyZWFkIG9yCisgICAgICAgIHdoZW4gdG9vIG1hbnkgdGFz a3MgYXJlIHBvc3RlZCBhbmQgdGhlIHF1ZXVlIGRvZXMgJ3N0b3AgYW5kIHJlLXNjaGVkdWxlJyB0 byBtYWtlIHN1cmUgcnVuIGxvb3AgaGFzIGEgY2hhbmNlIHRvIGV4ZWN1dGUgb3RoZXIgZXZlbnRz LgorCisgICAgICAgICogd3RmL21hYy9NYWluVGhyZWFkTWFjLm1tOgorICAgICAgICAoV1RGOjp0 aW1lckZpcmVkKToKKyAgICAgICAgKFdURjo6cG9zdFRpbWVyKToKKyAgICAgICAgKFdURjo6c2No ZWR1bGVEaXNwYXRjaEZ1bmN0aW9uc09uTWFpblRocmVhZCk6IFVzZSB0aW1lciBwb3N0ZWQgdG8g dGhlIGN1cnJlbnQgUnVuTG9vcCBpZiBzY2hlZHVsaW5nIHRoZSB0YXNrIGV4ZWN1dGlvbiB3aGls ZSBvbiB0aGUgbWFpbiB0aHJlYWQuCisKIDIwMTAtMDMtMDkgIEdhYm9yIExva2kgIDxsb2tpQHdl YmtpdC5vcmc+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgTWFjaWVqIFN0YWNob3dpYWsu CmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvbWFjL01haW5UaHJlYWRNYWMubW0gYi9K YXZhU2NyaXB0Q29yZS93dGYvbWFjL01haW5UaHJlYWRNYWMubW0KaW5kZXggMGRkZDVmNi4uMGY0 OTZkZiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL21hYy9NYWluVGhyZWFkTWFjLm1t CisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi9tYWMvTWFpblRocmVhZE1hYy5tbQpAQCAtMjksOCAr MjksMTAgQEAKICNpbXBvcnQgImNvbmZpZy5oIgogI2ltcG9ydCAiTWFpblRocmVhZC5oIgogCisj aW1wb3J0IDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogI2ltcG9ydCA8Rm91bmRh dGlvbi9OU1RocmVhZC5oPgogI2ltcG9ydCA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbXBvcnQgPHd0 Zi9UaHJlYWRpbmcuaD4KIAogQGludGVyZmFjZSBXVEZNYWluVGhyZWFkQ2FsbGVyIDogTlNPYmpl Y3QgewogfQpAQCAtNjMsOSArNjUsMzggQEAgdm9pZCBpbml0aWFsaXplTWFpblRocmVhZFBsYXRm b3JtKCkKICNlbmRpZgogfQogCitzdGF0aWMgYm9vbCBpc1RpbWVyUG9zdGVkOyAvLyBUaGlzIGlz IG9ubHkgYWNjZXNzZWQgb24gdGhlICdtYWluJyB0aHJlYWQuCisKK3N0YXRpYyB2b2lkIHRpbWVy RmlyZWQoQ0ZSdW5Mb29wVGltZXJSZWYgdGltZXIsIHZvaWQqKQoreworICAgIENGUmVsZWFzZSh0 aW1lcik7CisgICAgaXNUaW1lclBvc3RlZCA9IGZhbHNlOworICAgIFdURjo6ZGlzcGF0Y2hGdW5j dGlvbnNGcm9tTWFpblRocmVhZCgpOworfQorCit2b2lkIHBvc3RUaW1lcigpCit7CisgICAgQVNT RVJUKGlzTWFpblRocmVhZCgpKTsKKyNpZiBVU0UoV0VCX1RIUkVBRCkKKyAgICBBU1NFUlQod2Vi VGhyZWFkID09IFtOU1RocmVhZCBjdXJyZW50VGhyZWFkXSk7CisjZW5kaWYKKworICAgIGlmICgh aXNUaW1lclBvc3RlZCkgeworICAgICAgICBpc1RpbWVyUG9zdGVkID0gdHJ1ZTsKKyAgICAgICAg Q0ZSdW5Mb29wQWRkVGltZXIoQ0ZSdW5Mb29wR2V0Q3VycmVudCgpLCBDRlJ1bkxvb3BUaW1lckNy ZWF0ZSgwLCAwLCAwLCAwLCAwLCB0aW1lckZpcmVkLCAwKSwga0NGUnVuTG9vcENvbW1vbk1vZGVz KTsKKyAgICB9Cit9CisKKwogdm9pZCBzY2hlZHVsZURpc3BhdGNoRnVuY3Rpb25zT25NYWluVGhy ZWFkKCkKIHsKICAgICBBU1NFUlQoc3RhdGljTWFpblRocmVhZENhbGxlcik7CisKKyAgICBpZiAo aXNNYWluVGhyZWFkKCkpIHsKKyAgICAgICAgcG9zdFRpbWVyKCk7CisgICAgICAgIHJldHVybjsK KyAgICB9CisKICNpZiBVU0UoV0VCX1RIUkVBRCkKICAgICBbc3RhdGljTWFpblRocmVhZENhbGxl ciBwZXJmb3JtU2VsZWN0b3I6QHNlbGVjdG9yKGNhbGwpIG9uVGhyZWFkOndlYlRocmVhZCB3aXRo T2JqZWN0Om5pbCB3YWl0VW50aWxEb25lOk5PXTsKICNlbHNlCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggMmMxYjYxNi4uOTll YmU0YSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3Rz L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDEwLTAzLTEwICBEbWl0cnkgVGl0b3YgIDxk aW1pY2hAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIE1ha2UgRG9jdW1lbnQ6OnBvc3RUYXNrIHRvIHVzZSBhIHNpbmdsZSBxdWV1 ZSBvZiB0YXNrcywgdG8gZmlyZSB0aGVtIGluIG9yZGVyCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNTk0MworCisgICAgICAgIFVwZGF0ZWQgdGhlIHRl c3Qgc2luY2UgdGhlIG9yZGVyIG9mIGV2ZW50cyBjb21pbmcgZnJvbSBpbmRlcGVuZGVudCB0YXNr IHNvdXJjZXMgaGFzIGNoYW5nZWQuCisgICAgICAgIFRoaXMgaXMgYSBiZWhhdmlvciBjaGFuZ2Us IGJ1dCBpcyBjb25zaXN0ZW50IHdpdGggdGhlIHNwZWMgKHdoaWNoIHNwZWNpZmljYWxseSBzYXlz IHRoZXNlIGV2ZW50cyBtYXkgYmUgZmlyZWQKKyAgICAgICAgaW4gYW55IG9yZGVyKSBhbmQgdGhl IGxhc3QgdmVyc2lvbiBvZiBGRiAoMy41LjgpIHdoaWNoIHdhcyBjb21wbGV0aW5nIHRoZSB0ZXN0 IHN1Y2Nlc3NmdWxseS4KKworICAgICAgICAqIGh0dHAvdGVzdHMvYXBwY2FjaGUvdG9wLWZyYW1l LTItZXhwZWN0ZWQudHh0OgorICAgICAgICAqIGh0dHAvdGVzdHMvYXBwY2FjaGUvdG9wLWZyYW1l LTIuaHRtbDoKKwogMjAxMC0wMy0wOSAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21l Lm9yZz4KIAogICAgICAgICBbR1RLXSBGYWlscyBodHRwL3Rlc3RzL3BsdWdpbnMvdGhpcmQtcGFy dHktY29va2llLWFjY2VwdC1wb2xpY3kuaHRtbApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9hcHBjYWNoZS90b3AtZnJhbWUtMi1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL2FwcGNhY2hlL3RvcC1mcmFtZS0yLWV4cGVjdGVkLnR4dAppbmRleCA2ZTk5YmI2 Li40MWEzZmUwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL2FwcGNhY2hlL3Rv cC1mcmFtZS0yLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL2FwcGNh Y2hlL3RvcC1mcmFtZS0yLWV4cGVjdGVkLnR4dApAQCAtMiw2ICsyLDUgQEAgVGVzdCB0aGF0IGEg c3ViZnJhbWUgd2l0aG91dCBtYW5pZmVzdCBnZXRzIHBpY2tlZCBieSBhIHJlbGV2YW50IGFwcGxp Y2F0aW9uIGNhY2gKIAogU2hvdWxkIHNheSBTVUNDRVNTOgogCi1jaGVja2luZwogU1VDQ0VTUwog CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL2FwcGNhY2hlL3RvcC1mcmFtZS0y Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL2FwcGNhY2hlL3RvcC1mcmFtZS0yLmh0bWwK aW5kZXggYzIzOWQwOC4uZWRkZThjMiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9hcHBjYWNoZS90b3AtZnJhbWUtMi5odG1sCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv YXBwY2FjaGUvdG9wLWZyYW1lLTIuaHRtbApAQCAtMTYsMjYgKzE2LDQ3IEBAIGZ1bmN0aW9uIGxv ZyhtZXNzYWdlKQogICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHQiKS5pbm5lckhU TUwgKz0gbWVzc2FnZSArICI8YnI+IjsKIH0KIAorZnVuY3Rpb24gZGVidWcobWVzc2FnZSkKK3sK KyAgICAvLyBJZiBydW5uaW5nIG1hbnVhbGx5IGluIHRoZSBicm93c2VyLCBwcmludCB0aGUgc2Vx dWVuY2Ugb2YgZXZlbnRzLgorICAgIGlmICghd2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQor ICAgICAgICBsb2cobWVzc2FnZSk7Cit9CisKK3ZhciByZWNlaXZlZEV4cGVjdGVkTWVzc2FnZSA9 IGZhbHNlOwordmFyIHJlY2VpdmVkQ2hlY2tpbmdFdmVudCA9IGZhbHNlOwordmFyIHJlY2VpdmVk Tm91cGRhdGVFdmVudCA9IGZhbHNlOworCiBmdW5jdGlvbiB0ZXN0KCkKIHsKICAgICBhcHBsaWNh dGlvbkNhY2hlLm9ubm91cGRhdGUgPSBudWxsOwogICAgIGFwcGxpY2F0aW9uQ2FjaGUub25jYWNo ZWQgPSBudWxsOwogCiAgICAgLy8gV2hlbiBhIG5ldyBtYWluIHJlc291cmNlIGlzIGFzc29jaWF0 ZWQgd2l0aCB0aGUgY2FjaGUsIGFuIHVwZGF0ZSBzaG91bGQgYmUgc3RhcnRlZC4KLSAgICBhcHBs aWNhdGlvbkNhY2hlLm9uY2hlY2tpbmcgPSBmdW5jdGlvbigpIHsgbG9nKCJjaGVja2luZyIpIH0K KyAgICBhcHBsaWNhdGlvbkNhY2hlLm9uY2hlY2tpbmcgPSBmdW5jdGlvbigpIHsgZGVidWcoImNo ZWNraW5nIik7IHJlY2VpdmVkQ2hlY2tpbmdFdmVudCA9IHRydWU7IGNoZWNrRG9uZSgpOyAgfQor ICAgIGFwcGxpY2F0aW9uQ2FjaGUub25ub3VwZGF0ZSA9IGZ1bmN0aW9uKCkgeyBkZWJ1Zygibm91 cGRhdGUiKTsgcmVjZWl2ZWROb3VwZGF0ZUV2ZW50ID0gdHJ1ZTsgY2hlY2tEb25lKCk7ICB9CiAK ICAgICB2YXIgaWZyID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiaWZyYW1lIik7CiAgICAgaWZy LnNldEF0dHJpYnV0ZSgic3JjIiwgInJlc291cmNlcy9zdWJmcmFtZS0yLmh0bWwiKTsKICAgICBk b2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGlmcik7CiB9CiAKK2Z1bmN0aW9uIGNoZWNrRG9uZSgp Cit7CisgICAgaWYgKHJlY2VpdmVkRXhwZWN0ZWRNZXNzYWdlICYmIHJlY2VpdmVkQ2hlY2tpbmdF dmVudCAmJiByZWNlaXZlZE5vdXBkYXRlRXZlbnQpIHsKKyAgICAgICAgbG9nKCJTVUNDRVNTIik7 CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICBs YXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgfQorfQorCiBhcHBsaWNhdGlv bkNhY2hlLm9ubm91cGRhdGUgPSBmdW5jdGlvbigpIHsgdGVzdCgpIH0KIGFwcGxpY2F0aW9uQ2Fj aGUub25jYWNoZWQgPSBmdW5jdGlvbigpIHsgdGVzdCgpIH0KIAogYXBwbGljYXRpb25DYWNoZS5v bnVwZGF0ZXJlYWR5ID0gZnVuY3Rpb24oKSB7IGxvZygiRkFJTDogcmVjZWl2ZWQgdW5leHBlY3Rl ZCB1cGRhdGVyZWFkeSBldmVudCIpIH0KIGFwcGxpY2F0aW9uQ2FjaGUub25lcnJvciA9IGZ1bmN0 aW9uKCkgeyBsb2coIkZBSUw6IHJlY2VpdmVkIHVuZXhwZWN0ZWQgZXJyb3IgZXZlbnQiKSB9CiAK LXdpbmRvdy5hZGRFdmVudExpc3RlbmVyKCJtZXNzYWdlIiwgZnVuY3Rpb24oKSB7IGxvZygiU1VD Q0VTUyIpOyBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJv bGxlci5ub3RpZnlEb25lKCkgfSwgZmFsc2UpOword2luZG93LmFkZEV2ZW50TGlzdGVuZXIoIm1l c3NhZ2UiLCBmdW5jdGlvbigpIHsgZGVidWcoIm1lc3NhZ2UiKTsgcmVjZWl2ZWRFeHBlY3RlZE1l c3NhZ2UgPSB0cnVlOyBjaGVja0RvbmUoKTsgfSwgZmFsc2UpOwogCiA8L3NjcmlwdD4KIDwvYm9k eT4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5k ZXggMzA1NWIyMy4uMzgwODkxYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIv V2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wMy0wOSAgRG1pdHJ5IFRp dG92ICA8ZGltaWNoQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBNYWtlIERvY3VtZW50Ojpwb3N0VGFzayB0byB1c2UgYSBzaW5n bGUgcXVldWUgb2YgdGFza3MsIHRvIGZpcmUgdGhlbSBpbiBvcmRlcgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzU5NDMKKworICAgICAgICBUZXN0OiBl eGlzdGluZyB3b3JrZXItY2xvbmVwb3J0Lmh0bWwgd2hpY2ggd2FzIGJyb2tlbiBieSBpbml0aWFs IHBhdGNoIGluIGh0dHA6Ly90cmFjLndlYmtpdC5vcmcvY2hhbmdlc2V0LzU1NTkzLgorICAgICAg ICBBZGRpdGlvbmFsIHRlc3Qgd2hpY2ggaW5kaXJlY3RseSB2ZXJpZmllcyB0aGUgb3JkZXIgb2Yg ZXhlY3V0aW9uIHdpbGwgY29tZSBhcyBwYXJ0IG9mIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0zNDcyNgorCisgICAgICAgICogZG9tL0RvY3VtZW50LmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkRvY3VtZW50Ojpwb3N0VGFzayk6IEFsd2F5cyB1c2UgdGhlIHNhbWUgdGFz ayBxdWV1ZSwgaW5kZXBlbmRlbnQgb2Ygd2hhdCB0aHJlYWQgaXMgcG9zdGluZyB0aGUgdGFzay4K KwogMjAxMC0wMy0wOSAgQnJhZHkgRWlkc29uICA8YmVpZHNvbkBhcHBsZS5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Eb2N1 bWVudC5jcHAgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKaW5kZXggNzliZmE5Ny4uNDNjODQx YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCisrKyBiL1dlYkNvcmUvZG9t L0RvY3VtZW50LmNwcApAQCAtNDY4NSwyNSArNDY4NSw2IEBAIHZvaWQgRG9jdW1lbnQ6OnNjcmlw dEltcG9ydGVkKHVuc2lnbmVkIGxvbmcgaWRlbnRpZmllciwgY29uc3QgU3RyaW5nJiBzb3VyY2VT dHJpCiAjZW5kaWYKIH0KIAotY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dFRhc2tUaW1lciA6 IHB1YmxpYyBUaW1lckJhc2UgewotcHVibGljOgotICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHRU YXNrVGltZXIoUGFzc1JlZlB0cjxEb2N1bWVudD4gY29udGV4dCwgUGFzc093blB0cjxTY3JpcHRF eGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrKQotICAgICAgICA6IG1fY29udGV4dChjb250ZXh0 KQotICAgICAgICAsIG1fdGFzayh0YXNrKQotICAgIHsKLSAgICB9Ci0KLXByaXZhdGU6Ci0gICAg dmlydHVhbCB2b2lkIGZpcmVkKCkKLSAgICB7Ci0gICAgICAgIG1fdGFzay0+cGVyZm9ybVRhc2so bV9jb250ZXh0LmdldCgpKTsKLSAgICAgICAgZGVsZXRlIHRoaXM7Ci0gICAgfQotCi0gICAgUmVm UHRyPERvY3VtZW50PiBtX2NvbnRleHQ7Ci0gICAgT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2s+IG1fdGFzazsKLX07Ci0KIHN0cnVjdCBQZXJmb3JtVGFza0NvbnRleHQgOiBOb25j b3B5YWJsZSB7CiAgICAgUGVyZm9ybVRhc2tDb250ZXh0KFBhc3NSZWZQdHI8RG9jdW1lbnRXZWFr UmVmZXJlbmNlPiBkb2N1bWVudFJlZmVyZW5jZSwgUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpUYXNrPiB0YXNrKQogICAgICAgICA6IGRvY3VtZW50UmVmZXJlbmNlKGRvY3VtZW50 UmVmZXJlbmNlKQpAQCAtNDczMCwxMiArNDcxMSw3IEBAIHN0YXRpYyB2b2lkIHBlcmZvcm1UYXNr KHZvaWQqIGN0eCkKIAogdm9pZCBEb2N1bWVudDo6cG9zdFRhc2soUGFzc093blB0cjxUYXNrPiB0 YXNrKQogewotICAgIGlmIChpc01haW5UaHJlYWQoKSkgewotICAgICAgICBTY3JpcHRFeGVjdXRp b25Db250ZXh0VGFza1RpbWVyKiB0aW1lciA9IG5ldyBTY3JpcHRFeGVjdXRpb25Db250ZXh0VGFz a1RpbWVyKHN0YXRpY19jYXN0PERvY3VtZW50Kj4odGhpcyksIHRhc2spOwotICAgICAgICB0aW1l ci0+c3RhcnRPbmVTaG90KDApOwotICAgIH0gZWxzZSB7Ci0gICAgICAgIGNhbGxPbk1haW5UaHJl YWQocGVyZm9ybVRhc2ssIG5ldyBQZXJmb3JtVGFza0NvbnRleHQobV93ZWFrUmVmZXJlbmNlLCB0 YXNrKSk7Ci0gICAgfQorICAgIGNhbGxPbk1haW5UaHJlYWQocGVyZm9ybVRhc2ssIG5ldyBQZXJm b3JtVGFza0NvbnRleHQobV93ZWFrUmVmZXJlbmNlLCB0YXNrKSk7CiB9CiAKIEVsZW1lbnQqIERv Y3VtZW50OjpmaW5kQW5jaG9yKGNvbnN0IFN0cmluZyYgbmFtZSkK