23865 2009-02-10 03:42:10 -0800 Safari can be frozen by rapidly adding timers 2009-09-04 21:02:00 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) Mac OS X 10.5 RESOLVED FIXED P1 Normal --- 1 ap dimich darin ddkilzer dimich oliver yong.li.webkit oldest_to_newest 109109 0 ap 2009-02-10 03:42:10 -0800 Follow-up from bug 23705. The below code freezes Safari completely for me: --------------------- function test() { setTimeout(test, 0); setTimeout(test, 0); } setTimeout(test, 0); --------------------- 109116 1 darin 2009-02-10 08:52:51 -0800 Has this been true in the past, or is this something that recently changed? 109122 2 ap 2009-02-10 09:26:39 -0800 This is not a regression from 3.2.1 - I do not know about earlier versions. 109145 3 dimich 2009-02-10 11:08:10 -0800 From looking at the code, it can be happening for a long time. Timers are implemented using CFRunLoopAddTimer. According to Apple docs, the run loop fetches the timers first and input second. So if there is always a timer ready to be scheduled/fired, no input goes through. This script also freezes FF2 and IE7. 109166 4 darin 2009-02-10 12:38:48 -0800 (In reply to comment #3) > From looking at the code, it can be happening for a long time. Timers are > implemented using CFRunLoopAddTimer. According to Apple docs, the run loop > fetches the timers first and input second. So if there is always a timer ready > to be scheduled/fired, no input goes through. If that analysis is correct, then we do not need two timers in the test() function to make this happen, as we don't need exponential growth to have the problem. I suspect that's not the entire story. 109238 5 dimich 2009-02-10 20:28:16 -0800 Sorry, I should have done more experimenting before floating a theory above. The code Alexey used to file this bug can generate a lot of timers. Even though each of the invocations only creates 2 more and exits, the overall time in ThreadTimers::sharedTimerFiredInternal() grows exponentially. I've added printing of timer count and overall time spent there, here is the result: ** 2 timers, took 0.4 ms ** 10 timers, took 0.6 ms ** 14 timers, took 0.8 ms ** 16 timers, took 1.2 ms ** 26 timers, took 1.6 ms ** 31 timers, took 1.9 ms ** 20 timers, took 1.5 ms ** 22 timers, took 1.4 ms ** 21 timers, took 1.4 ms ** 45 timers, took 2.9 ms ** 81 timers, took 5.5 ms ** 145 timers, took 10.0 ms ** 285 timers, took 19.8 ms ** 546 timers, took 38.2 ms ** 1086 timers, took 78.6 ms ** 2159 timers, took 152.8 ms ** 4295 timers, took 301.6 ms ** 8611 timers, took 625.8 ms ** 17236 timers, took 1254.7 ms ** 34440 timers, took 2546.1 ms ** 69056 timers, took 5250.1 ms ** 138270 timers, took 10695.5 ms ** 276547 timers, took 22173.0 ms Each time the shared timer is fired, we go through collection of all timers and find out that they all are to be fired - so we loop through all and it takes ever-increasing time. As you can see, very quickly the time spent without returning to the run loop grows into seconds - so the beach ball appears and input events becomes very slow. It seems the input events such as mouse moves/clicks are accumulated and then dispatched in small portions between timer firing. So the user input would need several 'turns' with the timer to move the pointer/highlight the target/process the click. With growing interval between 'turns' it becomes nearly impossible. Note that timeout mechanism that measures if a piece of script runs too long and aborts it if so (preventing "while(true) {}" from freezing UI) would not help here because each particular JS callback is short. It seems that if we need to fix this, we need to measure how long we are executing timers and break out of the loop with posting another timer when we run them for too long. I'll have a patch soon. 109412 6 27585 dimich 2009-02-11 19:30:13 -0800 Created attachment 27585 Proposed patch This patch fires timers one by one, measuring elapsed time. If too much time elapses, it quits firing loop and reschedules. This allows thread run loop to run. Using the JS in description, it now does not freeze UI. However, if the script continues to run, the timer heap grows. If run for long time, one of 2 will happen: - user closes the tab and we freeze UI for a while removing millions of timers from timer heap - OOM and crash Do we need a variant of "Slow Script" dialog in case the page tries to create too many outstanding timers? 109413 7 dimich 2009-02-11 19:33:17 -0800 btw, I think that even separate from how the eventual OOM is handled, the proposed patch makes sense because it will help reduce number of cases when UI freezes, simplifies code and hopefully doesn't make something worse. 117314 8 27585 dimich 2009-04-13 10:52:03 -0700 Comment on attachment 27585 Proposed patch Removing r? since this needs a 'slow script' kind of detection too. 141835 9 38364 dimich 2009-08-20 23:39:50 -0700 Created attachment 38364 Path to fix UI freeze on long timer queue. Fix UI freezing by a long timer queue. The patch addresses the case when UI gets frozen because there are too many timers in the queue and the CPU can not process all of them quickly enough and starves the user input. This may be more pronounced on platforms like cellphones. The patch also simplifies the code a little - instead of taking all the ready timers out of the heap and then processing the copy, it takes them one by one. The recursive multiplication of timers that eventually causes out-of-memory condition should be addressed, if feasible, in a separate patch - since it likely involves some sort of limit on resources. If we need to split this bug, I can do that. 141838 10 dimich 2009-08-21 00:16:08 -0700 *** Bug 28455 has been marked as a duplicate of this bug. *** 144036 11 38364 abarth 2009-09-01 16:25:44 -0700 Comment on attachment 38364 Path to fix UI freeze on long timer queue. + static const int maxDurationOfFiringTimers = 0.050; This code makes no sense. This will just get rounded to zero. Also, can we write a test for this? Maybe have DRT queue up an event while firing a lot of timers? 144343 12 38950 dimich 2009-09-02 17:17:12 -0700 Created attachment 38950 Test file - load it into browser and see a UI freeze for 10 seconds. This is a manual test file reproducing the problem. The same file will be included into the patch, for WebCore/manula-test. It doesn't seem possible to create a DRT-based regular test because eventSender object that DRT uses to inject input does direct dispatching of the messages which makes it impossible to reproduce the freeze. Load the file into browser - it will freeze it for about 10 seconds by creating appropriate amount of timers. 144345 13 38952 dimich 2009-09-02 17:19:33 -0700 Created attachment 38952 Updated patch. Adam, thanks for taking a look! I think I've replaced a literal constant with a named one at the last moment... Updated patch - this time with manual test file (can't create a regular test for this). 144972 14 38952 levin 2009-09-04 18:06:18 -0700 Comment on attachment 38952 Updated patch. This is basically equivalent to what was there before with the addition of a maximum amount of time to process the timers. The removal of m_timersReadyToFire may cause a newly added timer to callback nearly immediately, but this should only happen for at most a millisecond (depending on the resolution of currentTime is that low) until currentTime() advances, so that seems fine. A few nits below to fix on landing. > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > +2009-09-02 Dmitry Titov <dimich@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + https://bugs.webkit.org/show_bug.cgi?id=23865 > + > + Prevent UI freeze in case when too many timers are in the timer queue. > + The fix measures the elapsed time while executing timers. If we have too many > + timers and it take significant time to fire, quit the loop and reschedule. "timers and it take*s*" > + This lets run loop to process user input (close the window for example). This lets the run loop process user input (close the window for example). > + (WebCore::TimerBase::setNextFireTime): > + Since timers are now fired one by one, there is no need to keep track of updated timers. > + * manual-tests/input-starved-by-timers.html: manual test that attempts to freeze browser by *M*anual test that... > diff --git a/WebCore/manual-tests/input-starved-by-timers.html b/WebCore/manual-tests/input-starved-by-timers.html > +var targetLatency = 10000; // multiply timers until it takes this much to fire all their callbacks. *M*ultiply > + // Create more timers, capture the current time so when callbacks are fired, Create more timers. Capture the ... > +function runTest() { > + log("Freezing UI..."); > + setTimeout(function() { timerCallback(new Date().getTime()); }, 0); > + setTimeout("multiplyFactor = 0; log('Finishing. Started to drain timers.');", 10000); It would be nice to stick with the 4 space indent that you did above. > diff --git a/WebCore/platform/ThreadTimers.cpp b/WebCore/platform/ThreadTimers.cpp > namespace WebCore { > > +// Fire timers until this time, then quit to let the run loop to process user input events. Consider: Fire timers for this length of time, and then quit to let the run loop process user input events. > +// 100ms is about perceptable delay in UI, have a half of ot as a threshold. Consider: 100ms is about a perceptible delay in UI, so use have a half of that as a threshold. > +// This is to prevent UI freeze when there are too much timers or machine performance is low. s/much/many/ > + while (!m_timerHeap.isEmpty() && m_timerHeap.first()->m_nextFireTime <= fireTime) { ... > + // Catch the case where the timer asked timers to fire in a nested event loop, or we are over time limit. > + if (!m_firingTimers || timeToQuit < currentTime()) Consider making this part of the "while" condition (of course that means the loop would never execute if timeToQuit > currentTime() at the beginning of the loop. On further consideration, I think this should remain here because that way we ensure that at least one timer got fired. (I had a hard time seeing how that could happen but maybe there is a slow/loaded machine...) 144980 15 dimich 2009-09-04 20:59:16 -0700 (In reply to comment #14) > > A few nits below to fix on landing. > > > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > > +2009-09-02 Dmitry Titov <dimich@chromium.org> > > + > > + Reviewed by NOBODY (OOPS!). > > + > > > + https://bugs.webkit.org/show_bug.cgi?id=23865 > > + > > + Prevent UI freeze in case when too many timers are in the timer queue. > > + The fix measures the elapsed time while executing timers. If we have too many > > > + timers and it take significant time to fire, quit the loop and reschedule. > "timers and it take*s*" > > > + This lets run loop to process user input (close the window for example). > > This lets the run loop process user input (close the window for example). > > > + (WebCore::TimerBase::setNextFireTime): > > + Since timers are now fired one by one, there is no need to keep track of updated timers. > > + * manual-tests/input-starved-by-timers.html: manual test that attempts to freeze browser by > *M*anual test that... > > > > diff --git a/WebCore/manual-tests/input-starved-by-timers.html b/WebCore/manual-tests/input-starved-by-timers.html > > +var targetLatency = 10000; // multiply timers until it takes this much to fire all their callbacks. > *M*ultiply > > > > + // Create more timers, capture the current time so when callbacks are fired, > Create more timers. Capture the ... > > > > +function runTest() { > > + log("Freezing UI..."); > > + setTimeout(function() { timerCallback(new Date().getTime()); }, 0); > > + setTimeout("multiplyFactor = 0; log('Finishing. Started to drain timers.');", 10000); > > It would be nice to stick with the 4 space indent that you did above. > > > diff --git a/WebCore/platform/ThreadTimers.cpp b/WebCore/platform/ThreadTimers.cpp > > namespace WebCore { > > > > +// Fire timers until this time, then quit to let the run loop to process user input events. > > Consider: > Fire timers for this length of time, and then quit to let the run loop > process user input events. > > > +// 100ms is about perceptable delay in UI, have a half of ot as a threshold. > > Consider: > 100ms is about a perceptible delay in UI, so use have a half of that as a > threshold. > > > +// This is to prevent UI freeze when there are too much timers or machine performance is low. > > s/much/many/ > > > + while (!m_timerHeap.isEmpty() && m_timerHeap.first()->m_nextFireTime <= fireTime) { > ... > > + // Catch the case where the timer asked timers to fire in a nested event loop, or we are over time limit. > > + if (!m_firingTimers || timeToQuit < currentTime()) > > Consider making this part of the "while" condition (of course that means the > loop would never execute if timeToQuit > currentTime() at the beginning of the > loop. > > On further consideration, I think this should remain here because that way we > ensure that at least one timer got fired. (I had a hard time seeing how that > could happen but maybe there is a slow/loaded machine...) 144981 16 dimich 2009-09-04 21:02:00 -0700 Ugh, previous entry was submitted by mistake. Fixed up and landed: http://trac.webkit.org/changeset/48086 I agree it's better to keep the exit check at the end of the loop, if only for better readability of that loop. 27585 2009-02-11 19:30:13 -0800 2009-08-20 23:39:50 -0700 Proposed patch seaOfTimers.txt text/plain 7297 dimich ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NGIzODBmMi4uOWRjMjUxOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNSBAQAorMjAwOS0wMi0xMSAgRG1pdHJ5IFRpdG92 ICA8ZGltaWNoQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjM4NjUKKworICAgICAgICBQcmV2ZW50IFVJIGZyZWV6ZSBpbiBjYXNlIGEgbG90IG9mIHRpbWVy cyBhcmUgcXVpY2tseSBjcmVhdGVkLgorICAgICAgICBUaGUgZml4IG1lYXN1cmVzIHRoZSBlbGFw c2VkIHRpbWUgb2YgZXhlY3V0aW5nIHRpbWVycy4gSWYgd2UgaGF2ZSB0b28gbWFueQorICAgICAg ICB0aW1lcnMgdGhhdCB0YWtlIHNpZ25pZmljYW50IHRpbWUgdG8gZmlyZSwgd2Ugbm93IHF1aXQg YW5kIHJlc2NoZWR1bGUuCisgICAgICAgIFRoaXMgbGV0cyBydW4gbG9vcCB0byBwcm9jZXNzIHVz ZXIgaW5wdXQgKGNsb3NlIHRoZSB3aW5kb3cgZm9yIGV4YW1wbGUpLgorCisgICAgICAgICogcGxh dGZvcm0vVGhyZWFkVGltZXJzLmg6CisgICAgICAgICogcGxhdGZvcm0vVGhyZWFkVGltZXJzLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZFRpbWVyczo6c2hhcmVkVGltZXJGaXJlZEludGVy bmFsKToKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZFRpbWVyczo6ZmlyZVRpbWVyc0luTmVzdGVk RXZlbnRMb29wKToKKyAgICAgICAgUmVtb3ZlZCBmdW5jdGlvbnMgYW5kIG1lbWJlcnMgdXNlZCBi ZWZvcmUgdG8gZ3JhYiBhIGxpc3Qgb2YgYWxsIGV4cGlyZWQgdGltZXJzLgorICAgICAgICBOb3cg d2UgZmV0Y2ggb25lIGJ5IG9uZSwgbWVhc3VyaW5nIHRpbWUgYW5kIHF1aXR0aW5nIHRoZSBsb29w IGlmIGl0IHRha2VzIHRvbyBsb25nLgorICAgICAgICAqIHBsYXRmb3JtL1RpbWVyLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlRpbWVyQmFzZTo6aXNBY3RpdmUpOgorICAgICAgICAoV2ViQ29yZTo6 VGltZXJCYXNlOjpzZXROZXh0RmlyZVRpbWUpOgorICAgICAgICBTaW5jZSB0aW1lcnMgYXJlIG5v dyBmaXJlZCBvbmUgYnkgb25lLCB0aGVyZSBpcyBubyBuZWVkIHRvIGtlZXAgdHJhY2sgb2YgdXBk YXRlZCB0aW1lcnMuCisKIDIwMDktMDItMTAgIE9saXZlciBIdW50ICA8b2xpdmVyQGFwcGxlLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBBZGVsZSBQZXRlcnNvbi4KZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGxhdGZvcm0vVGhyZWFkVGltZXJzLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFk VGltZXJzLmNwcAppbmRleCA3MWEwNmIwLi45YjQ0Mjc2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bs YXRmb3JtL1RocmVhZFRpbWVycy5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRUaW1l cnMuY3BwCkBAIC03OSw0MyArNzksNiBAQCB2b2lkIFRocmVhZFRpbWVyczo6dXBkYXRlU2hhcmVk VGltZXIoKQogICAgICAgICBtX3NoYXJlZFRpbWVyLT5zZXRGaXJlVGltZShtX3RpbWVySGVhcC5m aXJzdCgpLT5tX25leHRGaXJlVGltZSk7CiB9CiAKLQotdm9pZCBUaHJlYWRUaW1lcnM6OmNvbGxl Y3RGaXJpbmdUaW1lcnMoZG91YmxlIGZpcmVUaW1lLCBWZWN0b3I8VGltZXJCYXNlKj4mIGZpcmlu Z1RpbWVycykKLXsKLSAgICB3aGlsZSAoIW1fdGltZXJIZWFwLmlzRW1wdHkoKSAmJiBtX3RpbWVy SGVhcC5maXJzdCgpLT5tX25leHRGaXJlVGltZSA8PSBmaXJlVGltZSkgewotICAgICAgICBUaW1l ckJhc2UqIHRpbWVyID0gbV90aW1lckhlYXAuZmlyc3QoKTsKLSAgICAgICAgZmlyaW5nVGltZXJz LmFwcGVuZCh0aW1lcik7Ci0gICAgICAgIG1fdGltZXJzUmVhZHlUb0ZpcmUuYWRkKHRpbWVyKTsK LSAgICAgICAgdGltZXItPm1fbmV4dEZpcmVUaW1lID0gMDsKLSAgICAgICAgdGltZXItPmhlYXBE ZWxldGVNaW4oKTsKLSAgICB9Ci19Ci0KLXZvaWQgVGhyZWFkVGltZXJzOjpmaXJlVGltZXJzKGRv dWJsZSBmaXJlVGltZSwgY29uc3QgVmVjdG9yPFRpbWVyQmFzZSo+JiBmaXJpbmdUaW1lcnMpCi17 Ci0gICAgc2l6ZV90IHNpemUgPSBmaXJpbmdUaW1lcnMuc2l6ZSgpOwotICAgIGZvciAoc2l6ZV90 IGkgPSAwOyBpICE9IHNpemU7ICsraSkgewotICAgICAgICBUaW1lckJhc2UqIHRpbWVyID0gZmly aW5nVGltZXJzW2ldOwotCi0gICAgICAgIC8vIElmIG5vdCBpbiB0aGUgc2V0LCB0aGlzIHRpbWVy IGhhcyBiZWVuIGRlbGV0ZWQgb3IgcmUtc2NoZWR1bGVkIGluIGFub3RoZXIgdGltZXIncyBmaXJl ZCBmdW5jdGlvbi4KLSAgICAgICAgLy8gU28gZWl0aGVyIHdlIGRvbid0IHdhbnQgdG8gZmlyZSBp dCBhdCBhbGwgb3Igd2Ugd2lsbCBmaXJlIGl0IG5leHQgdGltZSB0aGUgc2hhcmVkIHRpbWVyIGdv ZXMgb2ZmLgotICAgICAgICAvLyBJdCBtaWdodCBldmVuIGhhdmUgYmVlbiBkZWxldGVkOyB0aGF0 J3MgT0sgYmVjYXVzZSB3ZSB3b24ndCBkbyBhbnl0aGluZyBlbHNlIHdpdGggdGhlIHBvaW50ZXIu Ci0gICAgICAgIGlmICghbV90aW1lcnNSZWFkeVRvRmlyZS5jb250YWlucyh0aW1lcikpCi0gICAg ICAgICAgICBjb250aW51ZTsKLQotICAgICAgICAvLyBTZXR0aW5nIHRoZSBuZXh0IGZpcmUgdGlt ZSBoYXMgYSBzaWRlIGVmZmVjdCBvZiByZW1vdmluZyB0aGUgdGltZXIgZnJvbSB0aGUgZmlyaW5n IHRpbWVycyBzZXQuCi0gICAgICAgIGRvdWJsZSBpbnRlcnZhbCA9IHRpbWVyLT5yZXBlYXRJbnRl cnZhbCgpOwotICAgICAgICB0aW1lci0+c2V0TmV4dEZpcmVUaW1lKGludGVydmFsID8gZmlyZVRp bWUgKyBpbnRlcnZhbCA6IDApOwotCi0gICAgICAgIC8vIE9uY2UgdGhlIHRpbWVyIGhhcyBiZWVu IGZpcmVkLCBpdCBtYXkgYmUgZGVsZXRlZCwgc28gZG8gbm90aGluZyBlbHNlIHdpdGggaXQgYWZ0 ZXIgdGhpcyBwb2ludC4KLSAgICAgICAgdGltZXItPmZpcmVkKCk7Ci0KLSAgICAgICAgLy8gQ2F0 Y2ggdGhlIGNhc2Ugd2hlcmUgdGhlIHRpbWVyIGFza2VkIHRpbWVycyB0byBmaXJlIGluIGEgbmVz dGVkIGV2ZW50IGxvb3AuCi0gICAgICAgIGlmICghbV9maXJpbmdUaW1lcnMpCi0gICAgICAgICAg ICBicmVhazsKLSAgICB9Ci19Ci0KIHZvaWQgVGhyZWFkVGltZXJzOjpzaGFyZWRUaW1lckZpcmVk KCkKIHsKICAgICAvLyBSZWRpcmVjdCB0byBub24tc3RhdGljIG1ldGhvZC4KQEAgLTEzMCwxNyAr OTMsMjYgQEAgdm9pZCBUaHJlYWRUaW1lcnM6OnNoYXJlZFRpbWVyRmlyZWRJbnRlcm5hbCgpCiAg ICAgbV9maXJpbmdUaW1lcnMgPSB0cnVlOwogCiAgICAgZG91YmxlIGZpcmVUaW1lID0gY3VycmVu dFRpbWUoKTsKLSAgICBWZWN0b3I8VGltZXJCYXNlKj4gZmlyaW5nVGltZXJzOworICAgIC8vIEZp cmUgdGltZXJzIHVudGlsIHRoaXMgdGltZSwgdGhlbiBxdWl0IHRvIGxldCBydW4gbG9vcCBwcm9j ZXNzIGlucHV0LgorICAgIC8vIDEwMG1zIGlzIGFib3V0IHBlcmNlcHRhYmxlIGRlbGF5IGluIFVJ LCBoYXZlIGEgaGFsZiBhcyBhIHRocmVzaG9sZC4KKyAgICBkb3VibGUgdGltZVRvUXVpdCA9IGZp cmVUaW1lICsgMC4wNTsKKworICAgIHdoaWxlICghbV90aW1lckhlYXAuaXNFbXB0eSgpICYmIG1f dGltZXJIZWFwLmZpcnN0KCktPm1fbmV4dEZpcmVUaW1lIDw9IGZpcmVUaW1lKSB7CisgICAgICAg IFRpbWVyQmFzZSogdGltZXIgPSBtX3RpbWVySGVhcC5maXJzdCgpOworICAgICAgICB0aW1lci0+ bV9uZXh0RmlyZVRpbWUgPSAwOworICAgICAgICB0aW1lci0+aGVhcERlbGV0ZU1pbigpOwogCi0g ICAgLy8gbV90aW1lcnNSZWFkeVRvRmlyZSB3aWxsIGluaXRpYWxseSBjb250YWluIHRoZSBzYW1l IHNldCBhcyBmaXJpbmdUaW1lcnMsIGJ1dAotICAgIC8vIGFzIHRpbWVycyBmaXJlIHNvbWUgbWF0 IGJlY29tZSByZS1zY2hlZHVsZWQgb3IgZGVsZXRlZC4gVGhleSBnZXQgcmVtb3ZlZCBmcm9tCi0g ICAgLy8gbV90aW1lcnNSZWFkeVRvRmlyZSBzbyB3ZSBjYW4gYXZvaWQgZmlyaW5nIHRoZW0uCi0g ICAgQVNTRVJUKG1fdGltZXJzUmVhZHlUb0ZpcmUuaXNFbXB0eSgpKTsKKyAgICAgICAgZG91Ymxl IGludGVydmFsID0gdGltZXItPnJlcGVhdEludGVydmFsKCk7CisgICAgICAgIHRpbWVyLT5zZXRO ZXh0RmlyZVRpbWUoaW50ZXJ2YWwgPyBmaXJlVGltZSArIGludGVydmFsIDogMCk7CiAKLSAgICBj b2xsZWN0RmlyaW5nVGltZXJzKGZpcmVUaW1lLCBmaXJpbmdUaW1lcnMpOwotICAgIGZpcmVUaW1l cnMoZmlyZVRpbWUsIGZpcmluZ1RpbWVycyk7CisgICAgICAgIC8vIE9uY2UgdGhlIHRpbWVyIGhh cyBiZWVuIGZpcmVkLCBpdCBtYXkgYmUgZGVsZXRlZCwgc28gZG8gbm90aGluZyBlbHNlIHdpdGgg aXQgYWZ0ZXIgdGhpcyBwb2ludC4KKyAgICAgICAgdGltZXItPmZpcmVkKCk7CisKKyAgICAgICAg Ly8gQ2F0Y2ggdGhlIGNhc2Ugd2hlcmUgdGhlIHRpbWVyIGFza2VkIHRpbWVycyB0byBmaXJlIGlu IGEgbmVzdGVkIGV2ZW50IGxvb3AuCisgICAgICAgIGlmICghbV9maXJpbmdUaW1lcnMgfHwgdGlt ZVRvUXVpdCA8IGN1cnJlbnRUaW1lKCkpCisgICAgICAgICAgICBicmVhazsKKyAgICB9CiAKLSAg ICBtX3RpbWVyc1JlYWR5VG9GaXJlLmNsZWFyKCk7CiAgICAgbV9maXJpbmdUaW1lcnMgPSBmYWxz ZTsKIAogICAgIHVwZGF0ZVNoYXJlZFRpbWVyKCk7CkBAIC0xNTAsNyArMTIyLDYgQEAgdm9pZCBU aHJlYWRUaW1lcnM6OmZpcmVUaW1lcnNJbk5lc3RlZEV2ZW50TG9vcCgpCiB7CiAgICAgLy8gUmVz ZXQgdGhlIHJlZW50cmFuY3kgZ3VhcmQgc28gdGhlIHRpbWVycyBjYW4gZmlyZSBhZ2Fpbi4KICAg ICBtX2ZpcmluZ1RpbWVycyA9IGZhbHNlOwotICAgIG1fdGltZXJzUmVhZHlUb0ZpcmUuY2xlYXIo KTsKICAgICB1cGRhdGVTaGFyZWRUaW1lcigpOwogfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3Bs YXRmb3JtL1RocmVhZFRpbWVycy5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRUaW1lcnMuaApp bmRleCAzNjZjMzIwLi4xMjUyNThlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL1RocmVh ZFRpbWVycy5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkVGltZXJzLmgKQEAgLTQ1LDcg KzQ1LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIHNldFNoYXJlZFRpbWVy KFNoYXJlZFRpbWVyKik7CiAKICAgICAgICAgVmVjdG9yPFRpbWVyQmFzZSo+JiB0aW1lckhlYXAo KSB7IHJldHVybiBtX3RpbWVySGVhcDsgfQotICAgICAgICBIYXNoU2V0PGNvbnN0IFRpbWVyQmFz ZSo+JiB0aW1lcnNSZWFkeVRvRmlyZSgpIHsgcmV0dXJuIG1fdGltZXJzUmVhZHlUb0ZpcmU7IH0K IAogICAgICAgICB2b2lkIHVwZGF0ZVNoYXJlZFRpbWVyKCk7CiAgICAgICAgIHZvaWQgZmlyZVRp bWVyc0luTmVzdGVkRXZlbnRMb29wKCk7CkBAIC01MywxMyArNTIsMTAgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogICAgIHByaXZhdGU6CiAgICAgICAgIHN0YXRpYyB2b2lkIHNoYXJlZFRpbWVyRmly ZWQoKTsKIAotICAgICAgICB2b2lkIGZpcmVUaW1lcnMoZG91YmxlIGZpcmVUaW1lLCBjb25zdCBW ZWN0b3I8VGltZXJCYXNlKj4mKTsKLSAgICAgICAgdm9pZCBjb2xsZWN0RmlyaW5nVGltZXJzKGRv dWJsZSBmaXJlVGltZSwgVmVjdG9yPFRpbWVyQmFzZSo+Jik7CiAgICAgICAgIHZvaWQgc2hhcmVk VGltZXJGaXJlZEludGVybmFsKCk7CiAgICAgICAgIHZvaWQgZmlyZVRpbWVyc0luTmVzdGVkRXZl bnRMb29wSW50ZXJuYWwoKTsKIAogICAgICAgICBWZWN0b3I8VGltZXJCYXNlKj4gbV90aW1lckhl YXA7Ci0gICAgICAgIEhhc2hTZXQ8Y29uc3QgVGltZXJCYXNlKj4gbV90aW1lcnNSZWFkeVRvRmly ZTsgLy8gVGVtcG9yYXJpbHkgaG9sZHMgYSBwb2ludGVyIHRvIGEgc3RhY2sgb2JqZWN0LiBObyBv d25lcnNoaXAuCiAgICAgICAgIFNoYXJlZFRpbWVyKiBtX3NoYXJlZFRpbWVyOyAvLyBFeHRlcm5h bCBvYmplY3QsIGNhbiBiZSBhIHJ1biBsb29wIG9uIGEgd29ya2VyIHRocmVhZC4gTm9ybWFsbHkg c2V0L3Jlc2V0IGJ5IHdvcmtlciB0aHJlYWQuCiAgICAgICAgIGJvb2wgbV9maXJpbmdUaW1lcnM7 IC8vIFJlZW50cmFuY3kgZ3VhcmQuCiAgICAgfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZv cm0vVGltZXIuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9UaW1lci5jcHAKaW5kZXggODgxZTQ4Yi4u ZWQzYjAyZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9UaW1lci5jcHAKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS9UaW1lci5jcHAKQEAgLTUzLDExICs1Myw2IEBAIHN0YXRpYyBWZWN0b3I8 VGltZXJCYXNlKj4mIHRpbWVySGVhcCgpCiAgICAgcmV0dXJuIHRocmVhZEdsb2JhbERhdGEoKS50 aHJlYWRUaW1lcnMoKS50aW1lckhlYXAoKTsKIH0KIAotc3RhdGljIEhhc2hTZXQ8Y29uc3QgVGlt ZXJCYXNlKj4mIHRpbWVyc1JlYWR5VG9GaXJlKCkKLXsKLSAgICByZXR1cm4gdGhyZWFkR2xvYmFs RGF0YSgpLnRocmVhZFRpbWVycygpLnRpbWVyc1JlYWR5VG9GaXJlKCk7Ci19Ci0KIC8vIENsYXNz IHRvIHJlcHJlc2VudCBlbGVtZW50cyBpbiB0aGUgaGVhcCB3aGVuIGNhbGxpbmcgdGhlIHN0YW5k YXJkIGxpYnJhcnkgaGVhcCBhbGdvcml0aG1zLgogLy8gTWFpbnRhaW5zIHRoZSBtX2hlYXBJbmRl eCB2YWx1ZSBpbiB0aGUgdGltZXJzIHRoZW1zZWx2ZXMsIHdoaWNoIGFsbG93cyB1cyB0byBkbyBl ZmZpY2llbnQKIC8vIG1vZGlmaWNhdGlvbiBvZiB0aGUgaGVhcC4KQEAgLTE5Niw3ICsxOTEsNyBA QCB2b2lkIFRpbWVyQmFzZTo6c3RvcCgpCiAKIGJvb2wgVGltZXJCYXNlOjppc0FjdGl2ZSgpIGNv bnN0CiB7Ci0gICAgcmV0dXJuIG1fbmV4dEZpcmVUaW1lIHx8IHRpbWVyc1JlYWR5VG9GaXJlKCku Y29udGFpbnModGhpcyk7CisgICAgcmV0dXJuIG1fbmV4dEZpcmVUaW1lOwogfQogCiBkb3VibGUg VGltZXJCYXNlOjpuZXh0RmlyZUludGVydmFsKCkgY29uc3QKQEAgLTI4NSw5ICsyODAsNiBAQCB2 b2lkIFRpbWVyQmFzZTo6aGVhcFBvcE1pbigpCiB2b2lkIFRpbWVyQmFzZTo6c2V0TmV4dEZpcmVU aW1lKGRvdWJsZSBuZXdUaW1lKQogewogICAgIC8vIEtlZXAgaGVhcCB2YWxpZCB3aGlsZSBjaGFu Z2luZyB0aGUgbmV4dC1maXJlIHRpbWUuCi0KLSAgICB0aW1lcnNSZWFkeVRvRmlyZSgpLnJlbW92 ZSh0aGlzKTsKLQogICAgIGRvdWJsZSBvbGRUaW1lID0gbV9uZXh0RmlyZVRpbWU7CiAgICAgaWYg KG9sZFRpbWUgIT0gbmV3VGltZSkgewogICAgICAgICBtX25leHRGaXJlVGltZSA9IG5ld1RpbWU7 Cg== 38364 2009-08-20 23:39:50 -0700 2009-09-02 17:19:33 -0700 Path to fix UI freeze on long timer queue. patch.txt text/plain 7777 dimich ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg Yzk1MDZiZC4uOGZkYjBiYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNSBAQAorMjAwOS0wOC0yMCAgRG1pdHJ5IFRpdG92 ICA8ZGltaWNoQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjM4NjUKKworICAgICAgICBQcmV2ZW50IFVJIGZyZWV6ZSBpbiBjYXNlIHdoZW4gdG9vIG1hbnkg dGltZXJzIGFyZSBpbiB0aGUgdGltZXIgcXVldWUuCisgICAgICAgIFRoZSBmaXggbWVhc3VyZXMg dGhlIGVsYXBzZWQgdGltZSB3aGlsZSBleGVjdXRpbmcgdGltZXJzLiBJZiB3ZSBoYXZlIHRvbyBt YW55CisgICAgICAgIHRpbWVycyBhbmQgaXQgdGFrZSBzaWduaWZpY2FudCB0aW1lIHRvIGZpcmUs IHF1aXQgdGhlIGxvb3AgYW5kIHJlc2NoZWR1bGUuCisgICAgICAgIFRoaXMgbGV0cyBydW4gbG9v cCB0byBwcm9jZXNzIHVzZXIgaW5wdXQgKGNsb3NlIHRoZSB3aW5kb3cgZm9yIGV4YW1wbGUpLgor CisgICAgICAgICogcGxhdGZvcm0vVGhyZWFkVGltZXJzLmg6CisgICAgICAgICogcGxhdGZvcm0v VGhyZWFkVGltZXJzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZFRpbWVyczo6c2hhcmVk VGltZXJGaXJlZEludGVybmFsKToKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZFRpbWVyczo6Zmly ZVRpbWVyc0luTmVzdGVkRXZlbnRMb29wKToKKyAgICAgICAgUmVtb3ZlZCBmdW5jdGlvbnMgYW5k IG1lbWJlcnMgdXNlZCBiZWZvcmUgdG8gZ3JhYiBhIGxpc3Qgb2YgYWxsIGV4cGlyZWQgdGltZXJz LgorICAgICAgICBOb3cgd2UgZmV0Y2ggb25lIGJ5IG9uZSwgbWVhc3VyaW5nIHRpbWUgYW5kIHF1 aXR0aW5nIHRoZSBsb29wIGlmIGl0IHRha2VzIHRvbyBsb25nLgorICAgICAgICAqIHBsYXRmb3Jt L1RpbWVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRpbWVyQmFzZTo6aXNBY3RpdmUpOgorICAg ICAgICAoV2ViQ29yZTo6VGltZXJCYXNlOjpzZXROZXh0RmlyZVRpbWUpOgorICAgICAgICBTaW5j ZSB0aW1lcnMgYXJlIG5vdyBmaXJlZCBvbmUgYnkgb25lLCB0aGVyZSBpcyBubyBuZWVkIHRvIGtl ZXAgdHJhY2sgb2YgdXBkYXRlZCB0aW1lcnMuCisKIDIwMDktMDgtMjAgIEJyaWFuIFdlaW5zdGVp biAgPGJ3ZWluc3RlaW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkZWxlIFBl dGVyc29uLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRUaW1lcnMuY3BwIGIv V2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRUaW1lcnMuY3BwCmluZGV4IDcxYTA2YjAuLjU1Y2RhMTcg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkVGltZXJzLmNwcAorKysgYi9XZWJD b3JlL3BsYXRmb3JtL1RocmVhZFRpbWVycy5jcHAKQEAgLTM0LDYgKzM0LDExIEBACiAKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAorLy8gRmlyZSB0aW1lcnMgdW50aWwgdGhpcyB0aW1lLCB0aGVuIHF1 aXQgdG8gbGV0IHRoZSBydW4gbG9vcCB0byBwcm9jZXNzIHVzZXIgaW5wdXQgZXZlbnRzLgorLy8g MTAwbXMgaXMgYWJvdXQgcGVyY2VwdGFibGUgZGVsYXkgaW4gVUksIGhhdmUgYSBoYWxmIG9mIG90 IGFzIGEgdGhyZXNob2xkLgorLy8gVGhpcyBpcyB0byBwcmV2ZW50IFVJIGZyZWV6ZSB3aGVuIHRo ZXJlIGFyZSB0b28gbXVjaCB0aW1lcnMgb3IgbWFjaGluZSBwZXJmb3JtYW5jZSBpcyBsb3cuCitz dGF0aWMgY29uc3QgaW50IG1heER1cmF0aW9uT2ZGaXJpbmdUaW1lcnMgPSAwLjA1MDsKKwogLy8g VGltZXJzIGFyZSBjcmVhdGVkLCBzdGFydGVkIGFuZCBmaXJlZCBvbiB0aGUgc2FtZSB0aHJlYWQs IGFuZCBlYWNoIHRocmVhZCBoYXMgaXRzIG93biBUaHJlYWRUaW1lcnMKIC8vIGNvcHkgdG8ga2Vl cCB0aGUgaGVhcCBhbmQgYSBzZXQgb2YgY3VycmVudGx5IGZpcmluZyB0aW1lcnMuCiAKQEAgLTc5 LDQzICs4NCw2IEBAIHZvaWQgVGhyZWFkVGltZXJzOjp1cGRhdGVTaGFyZWRUaW1lcigpCiAgICAg ICAgIG1fc2hhcmVkVGltZXItPnNldEZpcmVUaW1lKG1fdGltZXJIZWFwLmZpcnN0KCktPm1fbmV4 dEZpcmVUaW1lKTsKIH0KIAotCi12b2lkIFRocmVhZFRpbWVyczo6Y29sbGVjdEZpcmluZ1RpbWVy cyhkb3VibGUgZmlyZVRpbWUsIFZlY3RvcjxUaW1lckJhc2UqPiYgZmlyaW5nVGltZXJzKQotewot ICAgIHdoaWxlICghbV90aW1lckhlYXAuaXNFbXB0eSgpICYmIG1fdGltZXJIZWFwLmZpcnN0KCkt Pm1fbmV4dEZpcmVUaW1lIDw9IGZpcmVUaW1lKSB7Ci0gICAgICAgIFRpbWVyQmFzZSogdGltZXIg PSBtX3RpbWVySGVhcC5maXJzdCgpOwotICAgICAgICBmaXJpbmdUaW1lcnMuYXBwZW5kKHRpbWVy KTsKLSAgICAgICAgbV90aW1lcnNSZWFkeVRvRmlyZS5hZGQodGltZXIpOwotICAgICAgICB0aW1l ci0+bV9uZXh0RmlyZVRpbWUgPSAwOwotICAgICAgICB0aW1lci0+aGVhcERlbGV0ZU1pbigpOwot ICAgIH0KLX0KLQotdm9pZCBUaHJlYWRUaW1lcnM6OmZpcmVUaW1lcnMoZG91YmxlIGZpcmVUaW1l LCBjb25zdCBWZWN0b3I8VGltZXJCYXNlKj4mIGZpcmluZ1RpbWVycykKLXsKLSAgICBzaXplX3Qg c2l6ZSA9IGZpcmluZ1RpbWVycy5zaXplKCk7Ci0gICAgZm9yIChzaXplX3QgaSA9IDA7IGkgIT0g c2l6ZTsgKytpKSB7Ci0gICAgICAgIFRpbWVyQmFzZSogdGltZXIgPSBmaXJpbmdUaW1lcnNbaV07 Ci0KLSAgICAgICAgLy8gSWYgbm90IGluIHRoZSBzZXQsIHRoaXMgdGltZXIgaGFzIGJlZW4gZGVs ZXRlZCBvciByZS1zY2hlZHVsZWQgaW4gYW5vdGhlciB0aW1lcidzIGZpcmVkIGZ1bmN0aW9uLgot ICAgICAgICAvLyBTbyBlaXRoZXIgd2UgZG9uJ3Qgd2FudCB0byBmaXJlIGl0IGF0IGFsbCBvciB3 ZSB3aWxsIGZpcmUgaXQgbmV4dCB0aW1lIHRoZSBzaGFyZWQgdGltZXIgZ29lcyBvZmYuCi0gICAg ICAgIC8vIEl0IG1pZ2h0IGV2ZW4gaGF2ZSBiZWVuIGRlbGV0ZWQ7IHRoYXQncyBPSyBiZWNhdXNl IHdlIHdvbid0IGRvIGFueXRoaW5nIGVsc2Ugd2l0aCB0aGUgcG9pbnRlci4KLSAgICAgICAgaWYg KCFtX3RpbWVyc1JlYWR5VG9GaXJlLmNvbnRhaW5zKHRpbWVyKSkKLSAgICAgICAgICAgIGNvbnRp bnVlOwotCi0gICAgICAgIC8vIFNldHRpbmcgdGhlIG5leHQgZmlyZSB0aW1lIGhhcyBhIHNpZGUg ZWZmZWN0IG9mIHJlbW92aW5nIHRoZSB0aW1lciBmcm9tIHRoZSBmaXJpbmcgdGltZXJzIHNldC4K LSAgICAgICAgZG91YmxlIGludGVydmFsID0gdGltZXItPnJlcGVhdEludGVydmFsKCk7Ci0gICAg ICAgIHRpbWVyLT5zZXROZXh0RmlyZVRpbWUoaW50ZXJ2YWwgPyBmaXJlVGltZSArIGludGVydmFs IDogMCk7Ci0KLSAgICAgICAgLy8gT25jZSB0aGUgdGltZXIgaGFzIGJlZW4gZmlyZWQsIGl0IG1h eSBiZSBkZWxldGVkLCBzbyBkbyBub3RoaW5nIGVsc2Ugd2l0aCBpdCBhZnRlciB0aGlzIHBvaW50 LgotICAgICAgICB0aW1lci0+ZmlyZWQoKTsKLQotICAgICAgICAvLyBDYXRjaCB0aGUgY2FzZSB3 aGVyZSB0aGUgdGltZXIgYXNrZWQgdGltZXJzIHRvIGZpcmUgaW4gYSBuZXN0ZWQgZXZlbnQgbG9v cC4KLSAgICAgICAgaWYgKCFtX2ZpcmluZ1RpbWVycykKLSAgICAgICAgICAgIGJyZWFrOwotICAg IH0KLX0KLQogdm9pZCBUaHJlYWRUaW1lcnM6OnNoYXJlZFRpbWVyRmlyZWQoKQogewogICAgIC8v IFJlZGlyZWN0IHRvIG5vbi1zdGF0aWMgbWV0aG9kLgpAQCAtMTMwLDE3ICs5OCwyNCBAQCB2b2lk IFRocmVhZFRpbWVyczo6c2hhcmVkVGltZXJGaXJlZEludGVybmFsKCkKICAgICBtX2ZpcmluZ1Rp bWVycyA9IHRydWU7CiAKICAgICBkb3VibGUgZmlyZVRpbWUgPSBjdXJyZW50VGltZSgpOwotICAg IFZlY3RvcjxUaW1lckJhc2UqPiBmaXJpbmdUaW1lcnM7CisgICAgZG91YmxlIHRpbWVUb1F1aXQg PSBmaXJlVGltZSArIG1heER1cmF0aW9uT2ZGaXJpbmdUaW1lcnM7CiAKLSAgICAvLyBtX3RpbWVy c1JlYWR5VG9GaXJlIHdpbGwgaW5pdGlhbGx5IGNvbnRhaW4gdGhlIHNhbWUgc2V0IGFzIGZpcmlu Z1RpbWVycywgYnV0Ci0gICAgLy8gYXMgdGltZXJzIGZpcmUgc29tZSBtYXQgYmVjb21lIHJlLXNj aGVkdWxlZCBvciBkZWxldGVkLiBUaGV5IGdldCByZW1vdmVkIGZyb20KLSAgICAvLyBtX3RpbWVy c1JlYWR5VG9GaXJlIHNvIHdlIGNhbiBhdm9pZCBmaXJpbmcgdGhlbS4KLSAgICBBU1NFUlQobV90 aW1lcnNSZWFkeVRvRmlyZS5pc0VtcHR5KCkpOworICAgIHdoaWxlICghbV90aW1lckhlYXAuaXNF bXB0eSgpICYmIG1fdGltZXJIZWFwLmZpcnN0KCktPm1fbmV4dEZpcmVUaW1lIDw9IGZpcmVUaW1l KSB7CisgICAgICAgIFRpbWVyQmFzZSogdGltZXIgPSBtX3RpbWVySGVhcC5maXJzdCgpOworICAg ICAgICB0aW1lci0+bV9uZXh0RmlyZVRpbWUgPSAwOworICAgICAgICB0aW1lci0+aGVhcERlbGV0 ZU1pbigpOwogCi0gICAgY29sbGVjdEZpcmluZ1RpbWVycyhmaXJlVGltZSwgZmlyaW5nVGltZXJz KTsKLSAgICBmaXJlVGltZXJzKGZpcmVUaW1lLCBmaXJpbmdUaW1lcnMpOworICAgICAgICBkb3Vi bGUgaW50ZXJ2YWwgPSB0aW1lci0+cmVwZWF0SW50ZXJ2YWwoKTsKKyAgICAgICAgdGltZXItPnNl dE5leHRGaXJlVGltZShpbnRlcnZhbCA/IGZpcmVUaW1lICsgaW50ZXJ2YWwgOiAwKTsKKworICAg ICAgICAvLyBPbmNlIHRoZSB0aW1lciBoYXMgYmVlbiBmaXJlZCwgaXQgbWF5IGJlIGRlbGV0ZWQs IHNvIGRvIG5vdGhpbmcgZWxzZSB3aXRoIGl0IGFmdGVyIHRoaXMgcG9pbnQuCisgICAgICAgIHRp bWVyLT5maXJlZCgpOworCisgICAgICAgIC8vIENhdGNoIHRoZSBjYXNlIHdoZXJlIHRoZSB0aW1l ciBhc2tlZCB0aW1lcnMgdG8gZmlyZSBpbiBhIG5lc3RlZCBldmVudCBsb29wLCBvciB3ZSBhcmUg b3ZlciB0aW1lIGxpbWl0LgorICAgICAgICBpZiAoIW1fZmlyaW5nVGltZXJzIHx8IHRpbWVUb1F1 aXQgPCBjdXJyZW50VGltZSgpKQorICAgICAgICAgICAgYnJlYWs7CisgICAgfQogCi0gICAgbV90 aW1lcnNSZWFkeVRvRmlyZS5jbGVhcigpOwogICAgIG1fZmlyaW5nVGltZXJzID0gZmFsc2U7CiAK ICAgICB1cGRhdGVTaGFyZWRUaW1lcigpOwpAQCAtMTUwLDcgKzEyNSw2IEBAIHZvaWQgVGhyZWFk VGltZXJzOjpmaXJlVGltZXJzSW5OZXN0ZWRFdmVudExvb3AoKQogewogICAgIC8vIFJlc2V0IHRo ZSByZWVudHJhbmN5IGd1YXJkIHNvIHRoZSB0aW1lcnMgY2FuIGZpcmUgYWdhaW4uCiAgICAgbV9m aXJpbmdUaW1lcnMgPSBmYWxzZTsKLSAgICBtX3RpbWVyc1JlYWR5VG9GaXJlLmNsZWFyKCk7CiAg ICAgdXBkYXRlU2hhcmVkVGltZXIoKTsKIH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9y bS9UaHJlYWRUaW1lcnMuaCBiL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkVGltZXJzLmgKaW5kZXgg ZWEwYTM2Ni4uMDFiNGM3MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRUaW1l cnMuaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZFRpbWVycy5oCkBAIC00NSw3ICs0NSw2 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBzZXRTaGFyZWRUaW1lcihTaGFy ZWRUaW1lciopOwogCiAgICAgICAgIFZlY3RvcjxUaW1lckJhc2UqPiYgdGltZXJIZWFwKCkgeyBy ZXR1cm4gbV90aW1lckhlYXA7IH0KLSAgICAgICAgSGFzaFNldDxjb25zdCBUaW1lckJhc2UqPiYg dGltZXJzUmVhZHlUb0ZpcmUoKSB7IHJldHVybiBtX3RpbWVyc1JlYWR5VG9GaXJlOyB9CiAKICAg ICAgICAgdm9pZCB1cGRhdGVTaGFyZWRUaW1lcigpOwogICAgICAgICB2b2lkIGZpcmVUaW1lcnNJ bk5lc3RlZEV2ZW50TG9vcCgpOwpAQCAtNTMsMTMgKzUyLDEwIEBAIG5hbWVzcGFjZSBXZWJDb3Jl IHsKICAgICBwcml2YXRlOgogICAgICAgICBzdGF0aWMgdm9pZCBzaGFyZWRUaW1lckZpcmVkKCk7 CiAKLSAgICAgICAgdm9pZCBmaXJlVGltZXJzKGRvdWJsZSBmaXJlVGltZSwgY29uc3QgVmVjdG9y PFRpbWVyQmFzZSo+Jik7Ci0gICAgICAgIHZvaWQgY29sbGVjdEZpcmluZ1RpbWVycyhkb3VibGUg ZmlyZVRpbWUsIFZlY3RvcjxUaW1lckJhc2UqPiYpOwogICAgICAgICB2b2lkIHNoYXJlZFRpbWVy RmlyZWRJbnRlcm5hbCgpOwogICAgICAgICB2b2lkIGZpcmVUaW1lcnNJbk5lc3RlZEV2ZW50TG9v cEludGVybmFsKCk7CiAKICAgICAgICAgVmVjdG9yPFRpbWVyQmFzZSo+IG1fdGltZXJIZWFwOwot ICAgICAgICBIYXNoU2V0PGNvbnN0IFRpbWVyQmFzZSo+IG1fdGltZXJzUmVhZHlUb0ZpcmU7IC8v IFRlbXBvcmFyaWx5IGhvbGRzIGEgcG9pbnRlciB0byBhIHN0YWNrIG9iamVjdC4gTm8gb3duZXJz aGlwLgogICAgICAgICBTaGFyZWRUaW1lciogbV9zaGFyZWRUaW1lcjsgLy8gRXh0ZXJuYWwgb2Jq ZWN0LCBjYW4gYmUgYSBydW4gbG9vcCBvbiBhIHdvcmtlciB0aHJlYWQuIE5vcm1hbGx5IHNldC9y ZXNldCBieSB3b3JrZXIgdGhyZWFkLgogICAgICAgICBib29sIG1fZmlyaW5nVGltZXJzOyAvLyBS ZWVudHJhbmN5IGd1YXJkLgogICAgIH07CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1Rp bWVyLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vVGltZXIuY3BwCmluZGV4IGJkMjlmZDguLjUzOTg0 NmMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vVGltZXIuY3BwCisrKyBiL1dlYkNvcmUv cGxhdGZvcm0vVGltZXIuY3BwCkBAIC01MywxMSArNTMsNiBAQCBzdGF0aWMgVmVjdG9yPFRpbWVy QmFzZSo+JiB0aW1lckhlYXAoKQogICAgIHJldHVybiB0aHJlYWRHbG9iYWxEYXRhKCkudGhyZWFk VGltZXJzKCkudGltZXJIZWFwKCk7CiB9CiAKLXN0YXRpYyBIYXNoU2V0PGNvbnN0IFRpbWVyQmFz ZSo+JiB0aW1lcnNSZWFkeVRvRmlyZSgpCi17Ci0gICAgcmV0dXJuIHRocmVhZEdsb2JhbERhdGEo KS50aHJlYWRUaW1lcnMoKS50aW1lcnNSZWFkeVRvRmlyZSgpOwotfQotCiAvLyBDbGFzcyB0byBy ZXByZXNlbnQgZWxlbWVudHMgaW4gdGhlIGhlYXAgd2hlbiBjYWxsaW5nIHRoZSBzdGFuZGFyZCBs aWJyYXJ5IGhlYXAgYWxnb3JpdGhtcy4KIC8vIE1haW50YWlucyB0aGUgbV9oZWFwSW5kZXggdmFs dWUgaW4gdGhlIHRpbWVycyB0aGVtc2VsdmVzLCB3aGljaCBhbGxvd3MgdXMgdG8gZG8gZWZmaWNp ZW50CiAvLyBtb2RpZmljYXRpb24gb2YgdGhlIGhlYXAuCkBAIC0yMDUsNyArMjAwLDcgQEAgYm9v bCBUaW1lckJhc2U6OmlzQWN0aXZlKCkgY29uc3QKIHsKICAgICBBU1NFUlQobV90aHJlYWQgPT0g Y3VycmVudFRocmVhZCgpKTsKIAotICAgIHJldHVybiBtX25leHRGaXJlVGltZSB8fCB0aW1lcnNS ZWFkeVRvRmlyZSgpLmNvbnRhaW5zKHRoaXMpOworICAgIHJldHVybiBtX25leHRGaXJlVGltZTsK IH0KIAogZG91YmxlIFRpbWVyQmFzZTo6bmV4dEZpcmVJbnRlcnZhbCgpIGNvbnN0CkBAIC0yOTYs OSArMjkxLDYgQEAgdm9pZCBUaW1lckJhc2U6OnNldE5leHRGaXJlVGltZShkb3VibGUgbmV3VGlt ZSkKICAgICBBU1NFUlQobV90aHJlYWQgPT0gY3VycmVudFRocmVhZCgpKTsKIAogICAgIC8vIEtl ZXAgaGVhcCB2YWxpZCB3aGlsZSBjaGFuZ2luZyB0aGUgbmV4dC1maXJlIHRpbWUuCi0KLSAgICB0 aW1lcnNSZWFkeVRvRmlyZSgpLnJlbW92ZSh0aGlzKTsKLQogICAgIGRvdWJsZSBvbGRUaW1lID0g bV9uZXh0RmlyZVRpbWU7CiAgICAgaWYgKG9sZFRpbWUgIT0gbmV3VGltZSkgewogICAgICAgICBt X25leHRGaXJlVGltZSA9IG5ld1RpbWU7Cg== 38950 2009-09-02 17:17:12 -0700 2009-09-02 17:17:12 -0700 Test file - load it into browser and see a UI freeze for 10 seconds. input-starved-by-timers.html text/html 1852 dimich PGh0bWw+CjxoZWFkPgo8c2NyaXB0PgpmdW5jdGlvbiBsb2cobSkgewogICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImxvZyIpLmlubmVySFRNTCArPSBtICsgIjxicj4iOwp9Cgp2YXIgbXVsdGlw bHlGYWN0b3IgPSAyOyAgIC8vIENyZWF0ZSB0aGlzIG1hbnkgdGltZXJzIGluIGV2ZXJ5IHRpbWVy IGNhbGxiYWNrLgp2YXIgdGFyZ2V0TGF0ZW5jeSA9IDEwMDAwOyAvLyBtdWx0aXBseSB0aW1lcnMg dW50aWwgaXQgdGFrZXMgdGhpcyBtdWNoIHRvIGZpcmUgYWxsIHRoZWlyIGNhbGxiYWNrcy4KdmFy IHRpbWVyQ291bnQgPSAxOwoKZnVuY3Rpb24gdGltZXJDYWxsYmFjayhjcmVhdGlvblRpbWVzdGFt cCkgewogICAgLS10aW1lckNvdW50OwogICAgCiAgICBpZiAoIW11bHRpcGx5RmFjdG9yKSB7CiAg ICAgICAgaWYgKHRpbWVyQ291bnQgPT0gMCkKICAgICAgICAgICAgbG9nKCJObyBtb3JlIHRpbWVy cyAtIFVJIHNob3VsZCBiZSByZXNwb25zaXZlIG5vdy4iKTsKICAgICAgICByZXR1cm47CiAgICB9 CgogICAgLy8gQ3JlYXRlIG1vcmUgdGltZXJzLCBjYXB0dXJlIHRoZSBjdXJyZW50IHRpbWUgc28g d2hlbiBjYWxsYmFja3MgYXJlIGZpcmVkLAogICAgLy8gd2UgY2FuIGNoZWNrIGhvdyBsb25nIGl0 IGFjdHVhbGx5IHRvb2sgKGxhdGVuY3kgY2F1c2VkIGJ5IGEgbG9uZyB0aW1lciBxdWV1ZSkuCiAg ICB2YXIgdGltZXN0YW1wID0gbmV3IERhdGUoKS5nZXRUaW1lKCk7CiAgICBmb3IgKGkgPSAwOyBp IDwgbXVsdGlwbHlGYWN0b3I7ICsraSkgewogICAgICAgIHNldFRpbWVvdXQoZnVuY3Rpb24oKSB7 IHRpbWVyQ2FsbGJhY2sodGltZXN0YW1wKTsgfSwgMCk7CiAgICAgICAgKyt0aW1lckNvdW50Owog ICAgfQoKICAgIC8vIE9uY2UgdGhlIHRpbWVyIHF1ZXVlIGdldHMgbG9uZyBlbm91Z2ggZm9yIHRo ZSB0aW1lciBmaXJpbmcgbGF0ZW5jeSB0byBiZSBvdmVyIHRoZSBsaW1pdCwKICAgIC8vIHN0b3Ag bXVsdHBseWluZyB0aGVtIGFuZCBrZWVwIHRoZSBudW1iZXIgb2YgdGltZXJzIGNvbnN0YW50Lgog ICAgaWYgKG11bHRpcGx5RmFjdG9yID4gMSAmJiBuZXcgRGF0ZSgpLmdldFRpbWUoKSAtIGNyZWF0 aW9uVGltZXN0YW1wID4gdGFyZ2V0TGF0ZW5jeSkKICAgICAgICBtdWx0aXBseUZhY3RvciA9IDE7 Cn0KCmZ1bmN0aW9uIHJ1blRlc3QoKSB7CiAgbG9nKCJGcmVlemluZyBVSS4uLiIpOwogIHNldFRp bWVvdXQoZnVuY3Rpb24oKSB7IHRpbWVyQ2FsbGJhY2sobmV3IERhdGUoKS5nZXRUaW1lKCkpOyB9 LCAwKTsKICBzZXRUaW1lb3V0KCJtdWx0aXBseUZhY3RvciA9IDA7IGxvZygnRmluaXNoaW5nLiBT dGFydGVkIHRvIGRyYWluIHRpbWVycy4nKTsiLCAxMDAwMCk7Cn0KCjwvc2NyaXB0Pgo8L2hlYWQ+ Cjxib2R5IG9ubG9hZD0icnVuVGVzdCgpIj4KVGhpcyB0ZXN0IHdpbGwgY3JlYXRlIGVub3VnaCB0 aW1lcnMgdG8gZnJlZXplIGJyb3dzZXIgVUkuIEFmdGVyIDEwIHNlY29uZHMsIGl0IAp3aWxsIHN0 YXJ0IGRyYWluIHRoZSB0aW1lcnMgc28gdGhlIFVJIGJlY29tZXMgcmVzcG9uc2l2ZSBhZ2FpbiBp biBhIGZldyBzZWNvbmRzLgpZb3UgZG9uJ3QgbmVlZCB0byBraWxsIHRoZSBicm93c2VyLjxicj5J ZiB0aGUgYnVnIGlzIGZpeGVkLCB0aGVyZSB3aWxsIGJlIG5vClVJIGZyZWV6ZS4gUmVmcmVzaCB0 aGUgcGFnZSB0byByZXBlYXQgdGhlIGV4cGVyaW1lbnQuPGJyPlRyeSB0byBjbGljayBhdCB0aGlz IApidXR0b24gKG9yIGJyb3dzZXIncyBtZW51KSB3aGlsZSBVSSBpcyBmcm96ZW46IDxidXR0b24g b25jbGljaz0ibG9nKCdjbGlja2VkJykiPkNsaWNrIE1lPC9idXR0b24+IDxocj4KPGRpdiBpZD0i bG9nIj48L2Rpdj4KPC9ib2R5Pgo8L2h0bWw+Cg== 38952 2009-09-02 17:19:33 -0700 2009-09-04 18:06:17 -0700 Updated patch. patch_v2.txt text/plain 10432 dimich ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MTNjNjU0My4uYWQ4Nzg1ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMCBAQAorMjAwOS0wOS0wMiAgRG1pdHJ5IFRpdG92 ICA8ZGltaWNoQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjM4NjUKKworICAgICAgICBQcmV2ZW50IFVJIGZyZWV6ZSBpbiBjYXNlIHdoZW4gdG9vIG1hbnkg dGltZXJzIGFyZSBpbiB0aGUgdGltZXIgcXVldWUuCisgICAgICAgIFRoZSBmaXggbWVhc3VyZXMg dGhlIGVsYXBzZWQgdGltZSB3aGlsZSBleGVjdXRpbmcgdGltZXJzLiBJZiB3ZSBoYXZlIHRvbyBt YW55CisgICAgICAgIHRpbWVycyBhbmQgaXQgdGFrZSBzaWduaWZpY2FudCB0aW1lIHRvIGZpcmUs IHF1aXQgdGhlIGxvb3AgYW5kIHJlc2NoZWR1bGUuCisgICAgICAgIFRoaXMgbGV0cyBydW4gbG9v cCB0byBwcm9jZXNzIHVzZXIgaW5wdXQgKGNsb3NlIHRoZSB3aW5kb3cgZm9yIGV4YW1wbGUpLgor CisgICAgICAgICogcGxhdGZvcm0vVGhyZWFkVGltZXJzLmg6CisgICAgICAgICogcGxhdGZvcm0v VGhyZWFkVGltZXJzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZFRpbWVyczo6c2hhcmVk VGltZXJGaXJlZEludGVybmFsKToKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZFRpbWVyczo6Zmly ZVRpbWVyc0luTmVzdGVkRXZlbnRMb29wKToKKyAgICAgICAgUmVtb3ZlZCBmdW5jdGlvbnMgYW5k IG1lbWJlcnMgdXNlZCBiZWZvcmUgdG8gZ3JhYiBhIGxpc3Qgb2YgYWxsIGV4cGlyZWQgdGltZXJz LgorICAgICAgICBOb3cgd2UgZmV0Y2ggb25lIGJ5IG9uZSwgbWVhc3VyaW5nIHRpbWUgYW5kIHF1 aXR0aW5nIHRoZSBsb29wIGlmIGl0IHRha2VzIHRvbyBsb25nLgorICAgICAgICAqIHBsYXRmb3Jt L1RpbWVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRpbWVyQmFzZTo6aXNBY3RpdmUpOgorICAg ICAgICAoV2ViQ29yZTo6VGltZXJCYXNlOjpzZXROZXh0RmlyZVRpbWUpOgorICAgICAgICBTaW5j ZSB0aW1lcnMgYXJlIG5vdyBmaXJlZCBvbmUgYnkgb25lLCB0aGVyZSBpcyBubyBuZWVkIHRvIGtl ZXAgdHJhY2sgb2YgdXBkYXRlZCB0aW1lcnMuCisgICAgICAgICogbWFudWFsLXRlc3RzL2lucHV0 LXN0YXJ2ZWQtYnktdGltZXJzLmh0bWw6IG1hbnVhbCB0ZXN0IHRoYXQgYXR0ZW1wdHMgdG8gZnJl ZXplIGJyb3dzZXIgYnkKKyAgICAgICAgY3JlYXRpbmcgb2YgZW5vdWdoIHRpbWVycy4gSXQgdGhl biBrZWVwcyBVSSBmcm96ZW4gYW5kIGFmdGVyIDEwIHNlY29uZHMgc3RhcnRzIHRvIGRyYWluIHRo ZSB0aW1lcnMKKyAgICAgICAgc28gdGhlIGJyb3dzZXIgdW4tZnJlZXplcy4gVGhpcyBpcyBpbnN0 ZWFkIG9mIGEgcmVndWxhciBsYXlvdXQgdGVzdCBiZWNhdXNlIHdlIGRvbid0IGhhdmUgYSB3YXkK KyAgICAgICAgdG8gaW5qZWN0IGFuIGlucHV0IGV2ZW50cyB2aWEgcmVndWxhciBydW4gbG9vcCBp biBEUlQgLSBpbnN0ZWFkIHRoZXkgYXJlIGRpcmVjdGx5IGRpc3BhdGNoZWQgYnkKKyAgICAgICAg ZXZlbnRTZW5kZXIsIHdoaWNoIGRvZXMgbm90IHJlcHJvZHVjZSB0aGUgVUkgZnJlZXplIHRoYXQg aGFwcGVucyB3aXRoIHJlYWwgaW5wdXQuCisKIDIwMDktMDktMDEgIEFsZXhleSBQcm9za3VyeWFr b3YgIDxhcEBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRp ZmYgLS1naXQgYS9XZWJDb3JlL21hbnVhbC10ZXN0cy9pbnB1dC1zdGFydmVkLWJ5LXRpbWVycy5o dG1sIGIvV2ViQ29yZS9tYW51YWwtdGVzdHMvaW5wdXQtc3RhcnZlZC1ieS10aW1lcnMuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41MmIxZjE4Ci0tLSAvZGV2L251bGwK KysrIGIvV2ViQ29yZS9tYW51YWwtdGVzdHMvaW5wdXQtc3RhcnZlZC1ieS10aW1lcnMuaHRtbApA QCAtMCwwICsxLDUxIEBACis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdD4KK2Z1bmN0aW9uIGxvZyht KSB7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxvZyIpLmlubmVySFRNTCArPSBtICsg Ijxicj4iOworfQorCit2YXIgbXVsdGlwbHlGYWN0b3IgPSAyOyAgIC8vIENyZWF0ZSB0aGlzIG1h bnkgdGltZXJzIGluIGV2ZXJ5IHRpbWVyIGNhbGxiYWNrLgordmFyIHRhcmdldExhdGVuY3kgPSAx MDAwMDsgLy8gbXVsdGlwbHkgdGltZXJzIHVudGlsIGl0IHRha2VzIHRoaXMgbXVjaCB0byBmaXJl IGFsbCB0aGVpciBjYWxsYmFja3MuCit2YXIgdGltZXJDb3VudCA9IDE7CisKK2Z1bmN0aW9uIHRp bWVyQ2FsbGJhY2soY3JlYXRpb25UaW1lc3RhbXApIHsKKyAgICAtLXRpbWVyQ291bnQ7CisgICAg CisgICAgaWYgKCFtdWx0aXBseUZhY3RvcikgeworICAgICAgICBpZiAodGltZXJDb3VudCA9PSAw KQorICAgICAgICAgICAgbG9nKCJObyBtb3JlIHRpbWVycyAtIFVJIHNob3VsZCBiZSByZXNwb25z aXZlIG5vdy4iKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIC8vIENyZWF0ZSBtb3Jl IHRpbWVycywgY2FwdHVyZSB0aGUgY3VycmVudCB0aW1lIHNvIHdoZW4gY2FsbGJhY2tzIGFyZSBm aXJlZCwKKyAgICAvLyB3ZSBjYW4gY2hlY2sgaG93IGxvbmcgaXQgYWN0dWFsbHkgdG9vayAobGF0 ZW5jeSBjYXVzZWQgYnkgYSBsb25nIHRpbWVyIHF1ZXVlKS4KKyAgICB2YXIgdGltZXN0YW1wID0g bmV3IERhdGUoKS5nZXRUaW1lKCk7CisgICAgZm9yIChpID0gMDsgaSA8IG11bHRpcGx5RmFjdG9y OyArK2kpIHsKKyAgICAgICAgc2V0VGltZW91dChmdW5jdGlvbigpIHsgdGltZXJDYWxsYmFjayh0 aW1lc3RhbXApOyB9LCAwKTsKKyAgICAgICAgKyt0aW1lckNvdW50OworICAgIH0KKworICAgIC8v IE9uY2UgdGhlIHRpbWVyIHF1ZXVlIGdldHMgbG9uZyBlbm91Z2ggZm9yIHRoZSB0aW1lciBmaXJp bmcgbGF0ZW5jeSB0byBiZSBvdmVyIHRoZSBsaW1pdCwKKyAgICAvLyBzdG9wIG11bHRwbHlpbmcg dGhlbSBhbmQga2VlcCB0aGUgbnVtYmVyIG9mIHRpbWVycyBjb25zdGFudC4KKyAgICBpZiAobXVs dGlwbHlGYWN0b3IgPiAxICYmIG5ldyBEYXRlKCkuZ2V0VGltZSgpIC0gY3JlYXRpb25UaW1lc3Rh bXAgPiB0YXJnZXRMYXRlbmN5KQorICAgICAgICBtdWx0aXBseUZhY3RvciA9IDE7Cit9CisKK2Z1 bmN0aW9uIHJ1blRlc3QoKSB7CisgIGxvZygiRnJlZXppbmcgVUkuLi4iKTsKKyAgc2V0VGltZW91 dChmdW5jdGlvbigpIHsgdGltZXJDYWxsYmFjayhuZXcgRGF0ZSgpLmdldFRpbWUoKSk7IH0sIDAp OworICBzZXRUaW1lb3V0KCJtdWx0aXBseUZhY3RvciA9IDA7IGxvZygnRmluaXNoaW5nLiBTdGFy dGVkIHRvIGRyYWluIHRpbWVycy4nKTsiLCAxMDAwMCk7Cit9CisKKzwvc2NyaXB0PgorPC9oZWFk PgorPGJvZHkgb25sb2FkPSJydW5UZXN0KCkiPgorVGhpcyB0ZXN0IHdpbGwgY3JlYXRlIGVub3Vn aCB0aW1lcnMgdG8gZnJlZXplIGJyb3dzZXIgVUkuIEFmdGVyIDEwIHNlY29uZHMsIGl0IAord2ls bCBzdGFydCBkcmFpbiB0aGUgdGltZXJzIHNvIHRoZSBVSSBiZWNvbWVzIHJlc3BvbnNpdmUgYWdh aW4gaW4gYSBmZXcgc2Vjb25kcy4KK1lvdSBkb24ndCBuZWVkIHRvIGtpbGwgdGhlIGJyb3dzZXIu PGJyPklmIHRoZSBidWcgaXMgZml4ZWQsIHRoZXJlIHdpbGwgYmUgbm8KK1VJIGZyZWV6ZS4gUmVm cmVzaCB0aGUgcGFnZSB0byByZXBlYXQgdGhlIGV4cGVyaW1lbnQuPGJyPlRyeSB0byBjbGljayBh dCB0aGlzIAorYnV0dG9uIChvciBicm93c2VyJ3MgbWVudSkgd2hpbGUgVUkgaXMgZnJvemVuOiA8 YnV0dG9uIG9uY2xpY2s9ImxvZygnY2xpY2tlZCcpIj5DbGljayBNZTwvYnV0dG9uPiA8aHI+Cis8 ZGl2IGlkPSJsb2ciPjwvZGl2PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9wbGF0Zm9ybS9UaHJlYWRUaW1lcnMuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRUaW1l cnMuY3BwCmluZGV4IDcxYTA2YjAuLmM0OTYwNTcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZv cm0vVGhyZWFkVGltZXJzLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZFRpbWVycy5j cHAKQEAgLTM0LDYgKzM0LDExIEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorLy8gRmlyZSB0 aW1lcnMgdW50aWwgdGhpcyB0aW1lLCB0aGVuIHF1aXQgdG8gbGV0IHRoZSBydW4gbG9vcCB0byBw cm9jZXNzIHVzZXIgaW5wdXQgZXZlbnRzLgorLy8gMTAwbXMgaXMgYWJvdXQgcGVyY2VwdGFibGUg ZGVsYXkgaW4gVUksIGhhdmUgYSBoYWxmIG9mIG90IGFzIGEgdGhyZXNob2xkLgorLy8gVGhpcyBp cyB0byBwcmV2ZW50IFVJIGZyZWV6ZSB3aGVuIHRoZXJlIGFyZSB0b28gbXVjaCB0aW1lcnMgb3Ig bWFjaGluZSBwZXJmb3JtYW5jZSBpcyBsb3cuCitzdGF0aWMgY29uc3QgZG91YmxlIG1heER1cmF0 aW9uT2ZGaXJpbmdUaW1lcnMgPSAwLjA1MDsKKwogLy8gVGltZXJzIGFyZSBjcmVhdGVkLCBzdGFy dGVkIGFuZCBmaXJlZCBvbiB0aGUgc2FtZSB0aHJlYWQsIGFuZCBlYWNoIHRocmVhZCBoYXMgaXRz IG93biBUaHJlYWRUaW1lcnMKIC8vIGNvcHkgdG8ga2VlcCB0aGUgaGVhcCBhbmQgYSBzZXQgb2Yg Y3VycmVudGx5IGZpcmluZyB0aW1lcnMuCiAKQEAgLTc5LDQzICs4NCw2IEBAIHZvaWQgVGhyZWFk VGltZXJzOjp1cGRhdGVTaGFyZWRUaW1lcigpCiAgICAgICAgIG1fc2hhcmVkVGltZXItPnNldEZp cmVUaW1lKG1fdGltZXJIZWFwLmZpcnN0KCktPm1fbmV4dEZpcmVUaW1lKTsKIH0KIAotCi12b2lk IFRocmVhZFRpbWVyczo6Y29sbGVjdEZpcmluZ1RpbWVycyhkb3VibGUgZmlyZVRpbWUsIFZlY3Rv cjxUaW1lckJhc2UqPiYgZmlyaW5nVGltZXJzKQotewotICAgIHdoaWxlICghbV90aW1lckhlYXAu aXNFbXB0eSgpICYmIG1fdGltZXJIZWFwLmZpcnN0KCktPm1fbmV4dEZpcmVUaW1lIDw9IGZpcmVU aW1lKSB7Ci0gICAgICAgIFRpbWVyQmFzZSogdGltZXIgPSBtX3RpbWVySGVhcC5maXJzdCgpOwot ICAgICAgICBmaXJpbmdUaW1lcnMuYXBwZW5kKHRpbWVyKTsKLSAgICAgICAgbV90aW1lcnNSZWFk eVRvRmlyZS5hZGQodGltZXIpOwotICAgICAgICB0aW1lci0+bV9uZXh0RmlyZVRpbWUgPSAwOwot ICAgICAgICB0aW1lci0+aGVhcERlbGV0ZU1pbigpOwotICAgIH0KLX0KLQotdm9pZCBUaHJlYWRU aW1lcnM6OmZpcmVUaW1lcnMoZG91YmxlIGZpcmVUaW1lLCBjb25zdCBWZWN0b3I8VGltZXJCYXNl Kj4mIGZpcmluZ1RpbWVycykKLXsKLSAgICBzaXplX3Qgc2l6ZSA9IGZpcmluZ1RpbWVycy5zaXpl KCk7Ci0gICAgZm9yIChzaXplX3QgaSA9IDA7IGkgIT0gc2l6ZTsgKytpKSB7Ci0gICAgICAgIFRp bWVyQmFzZSogdGltZXIgPSBmaXJpbmdUaW1lcnNbaV07Ci0KLSAgICAgICAgLy8gSWYgbm90IGlu IHRoZSBzZXQsIHRoaXMgdGltZXIgaGFzIGJlZW4gZGVsZXRlZCBvciByZS1zY2hlZHVsZWQgaW4g YW5vdGhlciB0aW1lcidzIGZpcmVkIGZ1bmN0aW9uLgotICAgICAgICAvLyBTbyBlaXRoZXIgd2Ug ZG9uJ3Qgd2FudCB0byBmaXJlIGl0IGF0IGFsbCBvciB3ZSB3aWxsIGZpcmUgaXQgbmV4dCB0aW1l IHRoZSBzaGFyZWQgdGltZXIgZ29lcyBvZmYuCi0gICAgICAgIC8vIEl0IG1pZ2h0IGV2ZW4gaGF2 ZSBiZWVuIGRlbGV0ZWQ7IHRoYXQncyBPSyBiZWNhdXNlIHdlIHdvbid0IGRvIGFueXRoaW5nIGVs c2Ugd2l0aCB0aGUgcG9pbnRlci4KLSAgICAgICAgaWYgKCFtX3RpbWVyc1JlYWR5VG9GaXJlLmNv bnRhaW5zKHRpbWVyKSkKLSAgICAgICAgICAgIGNvbnRpbnVlOwotCi0gICAgICAgIC8vIFNldHRp bmcgdGhlIG5leHQgZmlyZSB0aW1lIGhhcyBhIHNpZGUgZWZmZWN0IG9mIHJlbW92aW5nIHRoZSB0 aW1lciBmcm9tIHRoZSBmaXJpbmcgdGltZXJzIHNldC4KLSAgICAgICAgZG91YmxlIGludGVydmFs ID0gdGltZXItPnJlcGVhdEludGVydmFsKCk7Ci0gICAgICAgIHRpbWVyLT5zZXROZXh0RmlyZVRp bWUoaW50ZXJ2YWwgPyBmaXJlVGltZSArIGludGVydmFsIDogMCk7Ci0KLSAgICAgICAgLy8gT25j ZSB0aGUgdGltZXIgaGFzIGJlZW4gZmlyZWQsIGl0IG1heSBiZSBkZWxldGVkLCBzbyBkbyBub3Ro aW5nIGVsc2Ugd2l0aCBpdCBhZnRlciB0aGlzIHBvaW50LgotICAgICAgICB0aW1lci0+ZmlyZWQo KTsKLQotICAgICAgICAvLyBDYXRjaCB0aGUgY2FzZSB3aGVyZSB0aGUgdGltZXIgYXNrZWQgdGlt ZXJzIHRvIGZpcmUgaW4gYSBuZXN0ZWQgZXZlbnQgbG9vcC4KLSAgICAgICAgaWYgKCFtX2Zpcmlu Z1RpbWVycykKLSAgICAgICAgICAgIGJyZWFrOwotICAgIH0KLX0KLQogdm9pZCBUaHJlYWRUaW1l cnM6OnNoYXJlZFRpbWVyRmlyZWQoKQogewogICAgIC8vIFJlZGlyZWN0IHRvIG5vbi1zdGF0aWMg bWV0aG9kLgpAQCAtMTMwLDE3ICs5OCwyNCBAQCB2b2lkIFRocmVhZFRpbWVyczo6c2hhcmVkVGlt ZXJGaXJlZEludGVybmFsKCkKICAgICBtX2ZpcmluZ1RpbWVycyA9IHRydWU7CiAKICAgICBkb3Vi bGUgZmlyZVRpbWUgPSBjdXJyZW50VGltZSgpOwotICAgIFZlY3RvcjxUaW1lckJhc2UqPiBmaXJp bmdUaW1lcnM7CisgICAgZG91YmxlIHRpbWVUb1F1aXQgPSBmaXJlVGltZSArIG1heER1cmF0aW9u T2ZGaXJpbmdUaW1lcnM7CiAKLSAgICAvLyBtX3RpbWVyc1JlYWR5VG9GaXJlIHdpbGwgaW5pdGlh bGx5IGNvbnRhaW4gdGhlIHNhbWUgc2V0IGFzIGZpcmluZ1RpbWVycywgYnV0Ci0gICAgLy8gYXMg dGltZXJzIGZpcmUgc29tZSBtYXQgYmVjb21lIHJlLXNjaGVkdWxlZCBvciBkZWxldGVkLiBUaGV5 IGdldCByZW1vdmVkIGZyb20KLSAgICAvLyBtX3RpbWVyc1JlYWR5VG9GaXJlIHNvIHdlIGNhbiBh dm9pZCBmaXJpbmcgdGhlbS4KLSAgICBBU1NFUlQobV90aW1lcnNSZWFkeVRvRmlyZS5pc0VtcHR5 KCkpOworICAgIHdoaWxlICghbV90aW1lckhlYXAuaXNFbXB0eSgpICYmIG1fdGltZXJIZWFwLmZp cnN0KCktPm1fbmV4dEZpcmVUaW1lIDw9IGZpcmVUaW1lKSB7CisgICAgICAgIFRpbWVyQmFzZSog dGltZXIgPSBtX3RpbWVySGVhcC5maXJzdCgpOworICAgICAgICB0aW1lci0+bV9uZXh0RmlyZVRp bWUgPSAwOworICAgICAgICB0aW1lci0+aGVhcERlbGV0ZU1pbigpOwogCi0gICAgY29sbGVjdEZp cmluZ1RpbWVycyhmaXJlVGltZSwgZmlyaW5nVGltZXJzKTsKLSAgICBmaXJlVGltZXJzKGZpcmVU aW1lLCBmaXJpbmdUaW1lcnMpOworICAgICAgICBkb3VibGUgaW50ZXJ2YWwgPSB0aW1lci0+cmVw ZWF0SW50ZXJ2YWwoKTsKKyAgICAgICAgdGltZXItPnNldE5leHRGaXJlVGltZShpbnRlcnZhbCA/ IGZpcmVUaW1lICsgaW50ZXJ2YWwgOiAwKTsKKworICAgICAgICAvLyBPbmNlIHRoZSB0aW1lciBo YXMgYmVlbiBmaXJlZCwgaXQgbWF5IGJlIGRlbGV0ZWQsIHNvIGRvIG5vdGhpbmcgZWxzZSB3aXRo IGl0IGFmdGVyIHRoaXMgcG9pbnQuCisgICAgICAgIHRpbWVyLT5maXJlZCgpOworCisgICAgICAg IC8vIENhdGNoIHRoZSBjYXNlIHdoZXJlIHRoZSB0aW1lciBhc2tlZCB0aW1lcnMgdG8gZmlyZSBp biBhIG5lc3RlZCBldmVudCBsb29wLCBvciB3ZSBhcmUgb3ZlciB0aW1lIGxpbWl0LgorICAgICAg ICBpZiAoIW1fZmlyaW5nVGltZXJzIHx8IHRpbWVUb1F1aXQgPCBjdXJyZW50VGltZSgpKQorICAg ICAgICAgICAgYnJlYWs7CisgICAgfQogCi0gICAgbV90aW1lcnNSZWFkeVRvRmlyZS5jbGVhcigp OwogICAgIG1fZmlyaW5nVGltZXJzID0gZmFsc2U7CiAKICAgICB1cGRhdGVTaGFyZWRUaW1lcigp OwpAQCAtMTUwLDcgKzEyNSw2IEBAIHZvaWQgVGhyZWFkVGltZXJzOjpmaXJlVGltZXJzSW5OZXN0 ZWRFdmVudExvb3AoKQogewogICAgIC8vIFJlc2V0IHRoZSByZWVudHJhbmN5IGd1YXJkIHNvIHRo ZSB0aW1lcnMgY2FuIGZpcmUgYWdhaW4uCiAgICAgbV9maXJpbmdUaW1lcnMgPSBmYWxzZTsKLSAg ICBtX3RpbWVyc1JlYWR5VG9GaXJlLmNsZWFyKCk7CiAgICAgdXBkYXRlU2hhcmVkVGltZXIoKTsK IH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRUaW1lcnMuaCBiL1dlYkNv cmUvcGxhdGZvcm0vVGhyZWFkVGltZXJzLmgKaW5kZXggZWEwYTM2Ni4uMDFiNGM3MSAxMDA2NDQK LS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRUaW1lcnMuaAorKysgYi9XZWJDb3JlL3BsYXRm b3JtL1RocmVhZFRpbWVycy5oCkBAIC00NSw3ICs0NSw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICAgICAgdm9pZCBzZXRTaGFyZWRUaW1lcihTaGFyZWRUaW1lciopOwogCiAgICAgICAgIFZl Y3RvcjxUaW1lckJhc2UqPiYgdGltZXJIZWFwKCkgeyByZXR1cm4gbV90aW1lckhlYXA7IH0KLSAg ICAgICAgSGFzaFNldDxjb25zdCBUaW1lckJhc2UqPiYgdGltZXJzUmVhZHlUb0ZpcmUoKSB7IHJl dHVybiBtX3RpbWVyc1JlYWR5VG9GaXJlOyB9CiAKICAgICAgICAgdm9pZCB1cGRhdGVTaGFyZWRU aW1lcigpOwogICAgICAgICB2b2lkIGZpcmVUaW1lcnNJbk5lc3RlZEV2ZW50TG9vcCgpOwpAQCAt NTMsMTMgKzUyLDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBwcml2YXRlOgogICAgICAg ICBzdGF0aWMgdm9pZCBzaGFyZWRUaW1lckZpcmVkKCk7CiAKLSAgICAgICAgdm9pZCBmaXJlVGlt ZXJzKGRvdWJsZSBmaXJlVGltZSwgY29uc3QgVmVjdG9yPFRpbWVyQmFzZSo+Jik7Ci0gICAgICAg IHZvaWQgY29sbGVjdEZpcmluZ1RpbWVycyhkb3VibGUgZmlyZVRpbWUsIFZlY3RvcjxUaW1lckJh c2UqPiYpOwogICAgICAgICB2b2lkIHNoYXJlZFRpbWVyRmlyZWRJbnRlcm5hbCgpOwogICAgICAg ICB2b2lkIGZpcmVUaW1lcnNJbk5lc3RlZEV2ZW50TG9vcEludGVybmFsKCk7CiAKICAgICAgICAg VmVjdG9yPFRpbWVyQmFzZSo+IG1fdGltZXJIZWFwOwotICAgICAgICBIYXNoU2V0PGNvbnN0IFRp bWVyQmFzZSo+IG1fdGltZXJzUmVhZHlUb0ZpcmU7IC8vIFRlbXBvcmFyaWx5IGhvbGRzIGEgcG9p bnRlciB0byBhIHN0YWNrIG9iamVjdC4gTm8gb3duZXJzaGlwLgogICAgICAgICBTaGFyZWRUaW1l ciogbV9zaGFyZWRUaW1lcjsgLy8gRXh0ZXJuYWwgb2JqZWN0LCBjYW4gYmUgYSBydW4gbG9vcCBv biBhIHdvcmtlciB0aHJlYWQuIE5vcm1hbGx5IHNldC9yZXNldCBieSB3b3JrZXIgdGhyZWFkLgog ICAgICAgICBib29sIG1fZmlyaW5nVGltZXJzOyAvLyBSZWVudHJhbmN5IGd1YXJkLgogICAgIH07 CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1RpbWVyLmNwcCBiL1dlYkNvcmUvcGxhdGZv cm0vVGltZXIuY3BwCmluZGV4IGJkMjlmZDguLjUzOTg0NmMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv cGxhdGZvcm0vVGltZXIuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vVGltZXIuY3BwCkBAIC01 MywxMSArNTMsNiBAQCBzdGF0aWMgVmVjdG9yPFRpbWVyQmFzZSo+JiB0aW1lckhlYXAoKQogICAg IHJldHVybiB0aHJlYWRHbG9iYWxEYXRhKCkudGhyZWFkVGltZXJzKCkudGltZXJIZWFwKCk7CiB9 CiAKLXN0YXRpYyBIYXNoU2V0PGNvbnN0IFRpbWVyQmFzZSo+JiB0aW1lcnNSZWFkeVRvRmlyZSgp Ci17Ci0gICAgcmV0dXJuIHRocmVhZEdsb2JhbERhdGEoKS50aHJlYWRUaW1lcnMoKS50aW1lcnNS ZWFkeVRvRmlyZSgpOwotfQotCiAvLyBDbGFzcyB0byByZXByZXNlbnQgZWxlbWVudHMgaW4gdGhl IGhlYXAgd2hlbiBjYWxsaW5nIHRoZSBzdGFuZGFyZCBsaWJyYXJ5IGhlYXAgYWxnb3JpdGhtcy4K IC8vIE1haW50YWlucyB0aGUgbV9oZWFwSW5kZXggdmFsdWUgaW4gdGhlIHRpbWVycyB0aGVtc2Vs dmVzLCB3aGljaCBhbGxvd3MgdXMgdG8gZG8gZWZmaWNpZW50CiAvLyBtb2RpZmljYXRpb24gb2Yg dGhlIGhlYXAuCkBAIC0yMDUsNyArMjAwLDcgQEAgYm9vbCBUaW1lckJhc2U6OmlzQWN0aXZlKCkg Y29uc3QKIHsKICAgICBBU1NFUlQobV90aHJlYWQgPT0gY3VycmVudFRocmVhZCgpKTsKIAotICAg IHJldHVybiBtX25leHRGaXJlVGltZSB8fCB0aW1lcnNSZWFkeVRvRmlyZSgpLmNvbnRhaW5zKHRo aXMpOworICAgIHJldHVybiBtX25leHRGaXJlVGltZTsKIH0KIAogZG91YmxlIFRpbWVyQmFzZTo6 bmV4dEZpcmVJbnRlcnZhbCgpIGNvbnN0CkBAIC0yOTYsOSArMjkxLDYgQEAgdm9pZCBUaW1lckJh c2U6OnNldE5leHRGaXJlVGltZShkb3VibGUgbmV3VGltZSkKICAgICBBU1NFUlQobV90aHJlYWQg PT0gY3VycmVudFRocmVhZCgpKTsKIAogICAgIC8vIEtlZXAgaGVhcCB2YWxpZCB3aGlsZSBjaGFu Z2luZyB0aGUgbmV4dC1maXJlIHRpbWUuCi0KLSAgICB0aW1lcnNSZWFkeVRvRmlyZSgpLnJlbW92 ZSh0aGlzKTsKLQogICAgIGRvdWJsZSBvbGRUaW1lID0gbV9uZXh0RmlyZVRpbWU7CiAgICAgaWYg KG9sZFRpbWUgIT0gbmV3VGltZSkgewogICAgICAgICBtX25leHRGaXJlVGltZSA9IG5ld1RpbWU7 Cg==