212338 2020-05-24 20:35:02 -0700 [WPE] Avoid possible WTR event timing going back in time and fix conversion from s to ms 2021-08-18 18:48:24 -0700 1 1 1 Unclassified WebKit WPE WebKit WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=177449 https://bugs.webkit.org/show_bug.cgi?id=229270 P2 Normal --- 1 lmoura lmoura aperez bugs-noreply cdumez cgarcia mcatanzaro oldest_to_newest 1655783 0 lmoura 2020-05-24 20:35:02 -0700 WPE's EventSenderProxy stores the event time (double m_time) as the elapsed number of seconds like other ports, but the native wpe_input_*_event uses uint32_t. EventSenderProxy casts the former to the latter without adjusting neither to a "real" time (more below) nor from seconds to milliseconds (wpe_input_*_event's timing unit). Also, when the event arrives in Source/WebKit/Shared/libwpe/WebEventFactory.cpp, WPE's implementation of wallTimeForEventTime will fallback to WallTime::now() if the timestamp is zero, using raw seconds otherwise. This can cause the WebEvents that started from zero having a WallTime in front of subsequent events that would come after a leapForward (for example, the event timestamps in fast/events/click-count.html) 1655784 1 400185 lmoura 2020-05-24 22:18:07 -0700 Created attachment 400185 Patch 1655785 2 lmoura 2020-05-24 22:21:40 -0700 Cc'ing mcatanzaro and cdumez (from the original discussion from bug 177449). 1655794 3 cgarcia 2020-05-24 23:58:21 -0700 Other ports don't use m_time for the events, it's only used to calculate the click count. 1655856 4 400185 mcatanzaro 2020-05-25 07:45:54 -0700 Comment on attachment 400185 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=400185&action=review > Source/WebKit/Shared/libwpe/WebEventFactory.cpp:66 > + // From wayland docs: > + // Input events also carry timestamps with millisecond granularity. Their base > + // is undefined, so they can't be compared against system time (as obtained > + // with clock_gettime or gettimeofday). They can be compared with each other > + // though, and for instance be used to identify sequences of button presses > + // as double or triple clicks. Same for X event timestamps. Anyway, I like your solution since it drops the assumption that the WPE backend (or, for GTK, the display server) is going to be using CLOCK_MONOTONIC. This is true for X11, and it's true for GNOME, and it's probably true for other Wayland compositors that exist today as well, so it's a "safe" assumption, but it's never really been correct. I was almost going to suggest changing the GTK implementation (duplicated in GtkUtilities.h and GtkUtilities.cpp) as well, but now I see that your real problem here is the handling of 0. In GTK, 0 always represents the current time (GDK_CURRENT_TIME) and it's normal to see events using it whenever. I understand from your comment that this handling is causing trouble for WPE, but I'm not sure I entirely understand how exactly.... Probably adding a comment on Wayland is not good to do here, btw, because WPE might not be using Wayland at all. Suffice to say that the WPE timestamp is always monotonically increasing and unrelated to wall time (like X or Wayland timestamps). > Source/WebKit/Shared/libwpe/WebEventFactory.cpp:72 > + std::unique_lock<std::mutex> lock(m); I would use std::call_once for this, it's nice and idiomatic. (We also have GOnce, but std::call_once is nicer in C++.) > LayoutTests/ChangeLog:12 > + Added new test to check if WPE input events timestamps are actually > + monotonically increasing since the start. > + > + * platform/wpe/fast/events/monotonic-event-time-expected.txt: Added. > + * platform/wpe/fast/events/monotonic-event-time.html: Added. Good test! I assume the test failed before your patch? This test should pass on all ports though, right? I don't think it should be WPE-specific. Try putting it under toplevel fast/events and see if it passes EWS. :) We've got a problem if timestamps are jumping around on any port! (If GTK or another port fails the test, you can add an appropriate TestExpectations line in order to land it without fixing that port. But hopefully no other port will fail the test.) 1655957 5 lmoura 2020-05-25 19:28:06 -0700 (In reply to Michael Catanzaro from comment #4) > Comment on attachment 400185 [details] > Patch > <snip> > I understand from your comment that this handling is causing trouble for WPE, > but I'm not sure I entirely understand how exactly.... The initial events (before a leapForward, for example), come with an event timestamp of 0. This caused the conversion to WallTime to return WallTime::now(). Once you leap forward, the event time becomes non-zero and would be a duration since the epoch (usually waaaaaay smaller than Now()). For example, I hit this issue in fast/events/click-count.html after rebasing the patch from bug174674 for WPE click counting. > Probably adding a comment on Wayland is not good to do here, btw, because > WPE might not be using Wayland at all. Suffice to say that the WPE timestamp > is always monotonically increasing and unrelated to wall time (like X or > Wayland timestamps). Right. > > > Source/WebKit/Shared/libwpe/WebEventFactory.cpp:72 > > + std::unique_lock<std::mutex> lock(m); > > I would use std::call_once for this, it's nice and idiomatic. (We also have > GOnce, but std::call_once is nicer in C++.) TIL std::call_once :D > > > LayoutTests/ChangeLog:12 > > + Added new test to check if WPE input events timestamps are actually > > + monotonically increasing since the start. > > + > > + * platform/wpe/fast/events/monotonic-event-time-expected.txt: Added. > > + * platform/wpe/fast/events/monotonic-event-time.html: Added. > > Good test! I assume the test failed before your patch? Yes, it failed before. > > This test should pass on all ports though, right? I don't think it should be > WPE-specific. Try putting it under top level fast/events and see if it passes > EWS. :) We've got a problem if timestamps are jumping around on any port! > (If GTK or another port fails the test, you can add an appropriate > TestExpectations line in order to land it without fixing that port. But > hopefully no other port will fail the test.) That sounds good. I tested GTK here (after adding missing mouseUps to complete the click) and it worked fine. I'll submit the updated patch through CQ to test other ports. 1655989 6 400185 lmoura 2020-05-26 02:37:24 -0700 Comment on attachment 400185 Patch Found an issue with this reference timing implementation when running multiple tests. Will investigate. 1656066 7 mcatanzaro 2020-05-26 09:40:38 -0700 (In reply to Lauro Moura from comment #5) > The initial events (before a leapForward, for example), come with an event > timestamp of 0. This caused the conversion to WallTime to return > WallTime::now(). So... in WPE, we want to treat 0 as the initial time rather than the current time, and therefore we need a different conversion function that we use for GTK. Yes? Since that is the fundamental problem, it would be good to mention in your comment. 1656068 8 mcatanzaro 2020-05-26 09:43:21 -0700 (In reply to Lauro Moura from comment #5) > Once you leap forward, the event time becomes non-zero and > would be a duration since the epoch (usually waaaaaay smaller than Now()). Wait, none of the timestamps here are duration since epoch. The WPE time should be a monotonic time (or, oddly, 0... why are events using timestamp 0?) and the WebKit times are all wall times (elapsed real time). What is "leap forward?" Changing system time should have no impact on monotonic time or wall time, right? 1656118 9 aperez 2020-05-26 12:14:00 -0700 (In reply to Michael Catanzaro from comment #8) > (In reply to Lauro Moura from comment #5) > > Once you leap forward, the event time becomes non-zero and > > would be a duration since the epoch (usually waaaaaay smaller than Now()). > > Wait, none of the timestamps here are duration since epoch. The WPE time > should be a monotonic time (or, oddly, 0... why are events using timestamp > 0?) and the WebKit times are all wall times (elapsed real time). > > What is "leap forward?" Changing system time should have no impact on > monotonic time or wall time, right? Changing the system time does NOT affect monotonic time, but DOES affect wall time, even when it's expressed as seconds from the Epoch, because contrary to what one may think, obtaining such a value is not just asking the kernel “give me how many seconds have passed since the Epoch”: you need to know the current date and time, and *then* subtract the date and time of the Epoch from it. If the current date and time change… well, the result of that calculation will change as well, and the “now” timestamp for Epoch-based wall time will leap back and forth as the system clock changes. Now in the context of WebKit: WallTime::now() calls g_get_real_time(), which in turn uses gettimeofday(), which is indeed affected by clock changes—it should be using clock_gettime() but that has basically the same problem. By the way, it's called “wall” time because if you had a wall clock, you could look at it and write down the same timestamp. And anybody can sneak in and change the handles of your beautiful wall clock in between the first time and the next you look at it ¯\_(ツ)_/¯ TL;DR: Never ever use wall time to measure time intervals reliably, which includes about 93.67% of the use cases of time in computing: wall time is to *display* things to the user. Now, after this long comment you may be left wondering: Why does the DOM events API use wall time, then? Dunno, but clearly whoever designed that API did not know better and now after it has been used in the wild cannot be changed, so we are stuck with it ¬_¬ 1656133 10 mcatanzaro 2020-05-26 12:31:40 -0700 Yeah so I misunderstood what wall time was, I thought it was equivalent of 'uptime'. Of course there would be no need to have such a class, that's effectively monotonic time.... 1656148 11 lmoura 2020-05-26 13:28:50 -0700 (In reply to Michael Catanzaro from comment #8) > (In reply to Lauro Moura from comment #5) > > Once you leap forward, the event time becomes non-zero and > > would be a duration since the epoch (usually waaaaaay smaller than Now()). > > Wait, none of the timestamps here are duration since epoch. The WPE time > should be a monotonic time (or, oddly, 0... why are events using timestamp > 0?) and the WebKit times are all wall times (elapsed real time). > > What is "leap forward?" Changing system time should have no impact on > monotonic time or wall time, right? Sorry, leap forward in the sense of eventSender.leapForward (changing the subsequent event timestamps). Not changing the system time. GTK's event sender proxy actually waits some time (to keep up with GDK_CURRENT_TIME usage), while Mac just stores this value, adding to the current time when converting from event timestamp to NSEvent. 1656157 12 lmoura 2020-05-26 13:41:27 -0700 (In reply to Adrian Perez from comment #9) > > Now, after this long comment you may be left wondering: Why does the > DOM events API use wall time, then? Dunno, but clearly whoever designed > that API did not know better and now after it has been used in the wild > cannot be changed, so we are stuck with it ¬_¬ DOM (in JS sense) events do not use wall time. They are DOMHighResTimeStamp [1], counted from some time origin[2]. But WebEvents in WebKit code indeed uses WallTime for the event timestamps, converting back to MonotonicTime later when creating their DOM (C) objects. [1] https://dom.spec.whatwg.org/#ref-for-dom-event-timestamp%E2%91%A3 [2] https://w3c.github.io/hr-time/#dfn-time-origin 1656267 13 lmoura 2020-05-26 19:55:09 -0700 (In reply to Lauro Moura from comment #6) > Comment on attachment 400185 [details] > Patch > > Found an issue with this reference timing implementation when running > multiple tests. Will investigate. So, the issue with the current iteration of the patch (just changing to call_once) happens when the same worker is used for multiple tests (Well, all the time). In these cases, the "timeOrigin" (LoadTiming::markStartTime()) is adjusted for each navigation, advancing the "frame of reference" used by the WebProcess when converting from the internal events WallTime to the DOM Monotonic time. Meanwhile, the event sender would start sending back events with 0 timestamp by default. In essence, the event timestamps given to wallTimeForEventTime were not monotonic. That said, instead of initializing EventSenderProxy::m_time (not used in absolute values, but relative, like cgarcia said in #c3) with 0, initializing it with the current MonotonicTime makes the test work fine (By guaranteeing that subsequent instantiations of the EventSender by the test controller will give monotonically increasing event timestamps). Would this be reasonable or raises some flags? 1656275 14 400303 lmoura 2020-05-26 20:15:29 -0700 Created attachment 400303 Updated patch initializing m_time to MonotonicTime::now 1656310 15 cgarcia 2020-05-27 00:50:30 -0700 (In reply to Lauro Moura from comment #11) > (In reply to Michael Catanzaro from comment #8) > > (In reply to Lauro Moura from comment #5) > > > Once you leap forward, the event time becomes non-zero and > > > would be a duration since the epoch (usually waaaaaay smaller than Now()). > > > > Wait, none of the timestamps here are duration since epoch. The WPE time > > should be a monotonic time (or, oddly, 0... why are events using timestamp > > 0?) and the WebKit times are all wall times (elapsed real time). > > > > What is "leap forward?" Changing system time should have no impact on > > monotonic time or wall time, right? > > Sorry, leap forward in the sense of eventSender.leapForward (changing the > subsequent event timestamps). Not changing the system time. > > GTK's event sender proxy actually waits some time (to keep up with > GDK_CURRENT_TIME usage), while Mac just stores this value, adding to the > current time when converting from event timestamp to NSEvent. Not anymore, since r262184 it behaves like other ports and the time is only used to calculate the click count. 1656346 16 400303 mcatanzaro 2020-05-27 06:07:11 -0700 Comment on attachment 400303 Updated patch initializing m_time to MonotonicTime::now You'll need to add a failure expectation for iOS-wk2: --- /Volumes/Data/worker/iOS-13-Simulator-WK2-Tests-EWS/build/layout-test-results/fast/events/monotonic-event-time-expected.txt +++ /Volumes/Data/worker/iOS-13-Simulator-WK2-Tests-EWS/build/layout-test-results/fast/events/monotonic-event-time-actual.txt @@ -3,10 +3,6 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE". -PASS lastTimeStamp < event.timeStamp is true -PASS lastTimeStamp < event.timeStamp is true -PASS lastTimeStamp < event.timeStamp is true -PASS lastTimeStamp < event.timeStamp is true PASS successfullyParsed is true TEST COMPLETE 1656503 17 400363 lmoura 2020-05-27 12:01:32 -0700 Created attachment 400363 Patch for landing Skipped in iOS altogether as it does not have mouse events. 1656557 18 ews-feeder 2020-05-27 13:45:48 -0700 Committed r262214: <https://trac.webkit.org/changeset/262214> All reviewed patches have been landed. Closing bug and clearing flags on attachment 400363. 1656684 19 lmoura 2020-05-27 17:07:07 -0700 There were two missing conversions making fast/events/touch/tap-highlight-color.html fail. Committed them unreviewed in r262225. 400185 2020-05-24 22:18:07 -0700 2020-05-26 02:37:24 -0700 Patch bug-212338-20200525021806.patch text/plain 13776 lmoura U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyMTExCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDQ3ZTI4ZGEwYTUxMWMwZDE2 YzA4YzYwZTQyMGRkNzUzNzdmYThkMmMuLjUzNDZiZGY5NDI0Njk0MDI5ZmY5M2E5ODBmMDhhY2Ey NGFlMjAxOTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjUgQEAKKzIwMjAtMDUtMjQgIExhdXJvIE1v dXJhICA8bG1vdXJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQRV0gQXZvaWQgcG9zc2libGUg V1RSIGV2ZW50IHRpbWluZyBnb2luZyBiYWNrIGluIHRpbWUgYW5kIGZpeCBjb252ZXJzaW9uIGZy b20gcyB0byBtcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjEyMzM4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgV2hlbiBjb252ZXJ0aW5nIHRoZSBpbnB1dCB0aW1lc3RhbXBzIHRvIFdhbGxUaW1lLCB3ZSBt dXN0IHNvbWVob3cKKyAgICAgICAgYWRqdXN0IHRoZW0gdG8gZ2l2ZSBtZWFuaW5nZnVsIHRpbWVz dGFtcHMgKGR1ZSB0byBEb206OkV2ZW50CisgICAgICAgIGNvbnZlcnNpb24gZnJvbSB0aW1lc3Rh bXAgd2FsbCB0aW1lIHRvIHRoZSB0aW1lIG9yaWdpbiBmcm9tIGRvY3VtZW50CisgICAgICAgIGxv YWRpbmcpLgorCisgICAgICAgIEFzIHdheWxhbmQgKHVzZWQgYXMgdGhlIHJlZmVyZW5jZSBXUEUg YmFja2VuZCkgdGltZXN0YW1wcyBhcmUganVzdAorICAgICAgICBpbnRlbmRlZCB0byBiZSBjb21w YXJlZCBhbW9uZyB0aGVtc2VsdmVzLCB3ZSB1c2UgdGhlIGZpcnN0IHByb2Nlc3NlZAorICAgICAg ICBldmVudCBhcyB0aGUgb3JpZ2luLCBjb21wYXJpbmcgdGhlIGZvbGxvd2luZyBldmVudHMgdG8g aXQgdG8gZ2V0IGFuCisgICAgICAgIGFjdHVhbCB0aW1lLgorCisgICAgICAgIFRlc3Q6IHBsYXRm b3JtL3dwZS9mYXN0L2V2ZW50cy9tb25vdG9uaWMtZXZlbnQtdGltZS5odG1sCisKKyAgICAgICAg KiBTaGFyZWQvbGlid3BlL1dlYkV2ZW50RmFjdG9yeS5jcHA6CisgICAgICAgIChXZWJLaXQ6Ondh bGxUaW1lRm9yRXZlbnRUaW1lKToKKwogMjAyMC0wNS0yNCAgU2FtIFdlaW5pZyAgPHdlaW5pZ0Bh cHBsZS5jb20+CiAKICAgICAgICAgRXh0ZW5kZWQgQ29sb3IgQ2xlYW51cDogU3RvcCBhbGxvd2lu ZyBkaXJlY3QgYWNjZXNzIHRvIHRoZSB1bmRlcmx5aW5nIFNpbXBsZUNvbG9yIChpdCBpcyBhbG1v c3QgYWx3YXlzIGluY29ycmVjdCB3aXRoIHJlc3BlY3QgdG8gZXh0ZW5kZWQgY29sb3JzKQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvbGlid3BlL1dlYkV2ZW50RmFjdG9yeS5jcHAg Yi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9saWJ3cGUvV2ViRXZlbnRGYWN0b3J5LmNwcAppbmRleCA2 MTU1NjI1OTdlZGUyZGU1OGU3Y2M3MzVjZGUzODQxMDMwOTcyNzI4Li5mNDU0N2I2YzU3NDhkZDkw MzliZTY0ZDI2ZTI3MDZiNDMwMDFhZGRhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NoYXJl ZC9saWJ3cGUvV2ViRXZlbnRGYWN0b3J5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9s aWJ3cGUvV2ViRXZlbnRGYWN0b3J5LmNwcApAQCAtNTIsMTQgKzUyLDM0IEBAIHN0YXRpYyBPcHRp b25TZXQ8V2ViRXZlbnQ6Ok1vZGlmaWVyPiBtb2RpZmllcnNGb3JFdmVudE1vZGlmaWVycyh1bnNp Z25lZCBldmVudE1vCiAgICAgcmV0dXJuIG1vZGlmaWVyczsKIH0KIAotV2FsbFRpbWUgd2FsbFRp bWVGb3JFdmVudFRpbWUodWludDY0X3QgdGltZXN0YW1wKQorV2FsbFRpbWUgd2FsbFRpbWVGb3JF dmVudFRpbWUodWludDY0X3QgbXNUaW1lU3RhbXApCiB7Ci0gICAgLy8gVGhpcyB3b3JrcyBpZiBh bmQgb25seSBpZiB0aGUgV1BFIGJhY2tlbmQgdXNlcyBDTE9DS19NT05PVE9OSUMgZm9yIGl0cwot ICAgIC8vIGV2ZW50IHRpbWVzdGFtcHMsIGFuZCBzbyBsb25nIGFzIGdfZ2V0X21vbm90b25pY190 aW1lKCkgY29udGludWVzIHRvIGRvCi0gICAgLy8gc28gYXMgd2VsbCwgYW5kIHNvIGxvbmcgYXMg V1RGOjpNb25vdG9uaWNUaW1lIGNvbnRpbnVlcyB0byB1c2UKLSAgICAvLyBnX2dldF9tb25vdG9u aWNfdGltZSgpLiBJdCBhbHNvIGFzc3VtZXMgdGhlIGV2ZW50IHRpbWVzdGFtcCBpcyBpbgotICAg IC8vIG1pbGxpc2Vjb25kcy4KLSAgICByZXR1cm4gdGltZXN0YW1wID8gTW9ub3RvbmljVGltZTo6 ZnJvbVJhd1NlY29uZHModGltZXN0YW1wIC8gMTAwMC4pLmFwcHJveGltYXRlV2FsbFRpbWUoKSA6 IFdhbGxUaW1lOjpub3coKTsKKyAgICAvLyBXUEUgZXZlbnQgdGltZSBmaWVsZCBpcyBhbiB1aW50 MzJfdCwgdG9vIHNtYWxsIGZvciBmdWxsIG1zIHRpbWVzdGFtcHMgc2luY2UKKyAgICAvLyB0aGUg ZXBvY2ggYW5kLCBiYXNlZCBvbiB3YXlsYW5kIGV2ZW50cywgdGhleSBhcmUganVzdCB0aW1lc3Rh bXBzIHdpdGgKKyAgICAvLyBtb25vdG9uaWMgYmVoYXZpb3IgaW5zdGVhZCBvZiBhbiBhY3R1YWwg cG9pbnQgaW4gdGltZSBzaW5jZSB0aGUgZXBvY2guCisgICAgLy8KKyAgICAvLyBGcm9tIHdheWxh bmQgZG9jczoKKyAgICAvLyAgSW5wdXQgZXZlbnRzIGFsc28gY2FycnkgdGltZXN0YW1wcyB3aXRo IG1pbGxpc2Vjb25kIGdyYW51bGFyaXR5LiBUaGVpciBiYXNlCisgICAgLy8gIGlzIHVuZGVmaW5l ZCwgc28gdGhleSBjYW4ndCBiZSBjb21wYXJlZCBhZ2FpbnN0IHN5c3RlbSB0aW1lIChhcyBvYnRh aW5lZAorICAgIC8vICB3aXRoIGNsb2NrX2dldHRpbWUgb3IgZ2V0dGltZW9mZGF5KS4gVGhleSBj YW4gYmUgY29tcGFyZWQgd2l0aCBlYWNoIG90aGVyCisgICAgLy8gIHRob3VnaCwgYW5kIGZvciBp bnN0YW5jZSBiZSB1c2VkIHRvIGlkZW50aWZ5IHNlcXVlbmNlcyBvZiBidXR0b24gcHJlc3Nlcwor ICAgIC8vICBhcyBkb3VibGUgb3IgdHJpcGxlIGNsaWNrcy4KKworICAgIHN0YXRpYyB1aW50NjRf dCBmaXJzdEV2ZW50VGltZVN0YW1wID0gMDsKKyAgICBzdGF0aWMgV2FsbFRpbWUgZmlyc3RFdmVu dFdhbGxUaW1lID0gV2FsbFRpbWU6OmZyb21SYXdTZWNvbmRzKDApOworICAgIHN0YXRpYyBzdGQ6 Om11dGV4IG07CisKKyAgICBzdGQ6OnVuaXF1ZV9sb2NrPHN0ZDo6bXV0ZXg+IGxvY2sobSk7CisK KyAgICBpZiAoIXN0YXRpY19jYXN0PGJvb2w+KGZpcnN0RXZlbnRXYWxsVGltZSkpIHsKKyAgICAg ICAgZmlyc3RFdmVudFRpbWVTdGFtcCA9IG1zVGltZVN0YW1wOworICAgICAgICBmaXJzdEV2ZW50 V2FsbFRpbWUgPSBXYWxsVGltZTo6bm93KCk7CisgICAgICAgIHJldHVybiBmaXJzdEV2ZW50V2Fs bFRpbWU7CisgICAgfQorCisgICAgdWludDY0X3QgZGVsdGEgPSBtc1RpbWVTdGFtcCAtIGZpcnN0 RXZlbnRUaW1lU3RhbXA7CisKKyAgICByZXR1cm4gZmlyc3RFdmVudFdhbGxUaW1lICsgU2Vjb25k cyhkZWx0YSAvIDEwMDAuKTsKIH0KIAogV2ViS2V5Ym9hcmRFdmVudCBXZWJFdmVudEZhY3Rvcnk6 OmNyZWF0ZVdlYktleWJvYXJkRXZlbnQoc3RydWN0IHdwZV9pbnB1dF9rZXlib2FyZF9ldmVudCog ZXZlbnQsIGNvbnN0IFN0cmluZyYgdGV4dCwgYm9vbCBoYW5kbGVkQnlJbnB1dE1ldGhvZCwgT3B0 aW9uYWw8VmVjdG9yPFdlYkNvcmU6OkNvbXBvc2l0aW9uVW5kZXJsaW5lPj4mJiBwcmVlZGl0VW5k ZXJsaW5lcywgT3B0aW9uYWw8RWRpdGluZ1JhbmdlPiYmIHByZWVkaXRTZWxlY3Rpb25SYW5nZSkK ZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBkNjkx NWUyNGQ4ZTNhMjE4YjMxMjQ2ZDZiMTQwZGZlMWU0MzkyY2JlLi5lMjUwZjJiZmNkOTI0Mjk1MzAy YzcyZjhlMjNlODQ0MDZjY2YyN2FjIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIv VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMjAtMDUtMjQgIExhdXJvIE1vdXJh ICA8bG1vdXJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQRV0gQXZvaWQgcG9zc2libGUgV1RS IGV2ZW50IHRpbWluZyBnb2luZyBiYWNrIGluIHRpbWUgYW5kIGZpeCBjb252ZXJzaW9uIGZyb20g cyB0byBtcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjEyMzM4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg TWFrZSBzdXJlIHdlIGNhc3QgdGhlIGRvdWJsZSBtX3RpbWUgdGltZXN0YW1wIGZyb20gc2Vjb25k cyB0byB1aW50MzJfdAorICAgICAgICBtaWxsaXNlY29uZHMgZXhwZWN0ZWQgYnkgV1BFIGlucHV0 IGV2ZW50cy4KKworICAgICAgICAqIFdlYktpdFRlc3RSdW5uZXIvd3BlL0V2ZW50U2VuZGVyUHJv eHlXUEUuY3BwOgorICAgICAgICAoV1RSOjpzZWNUb01zVGltZXN0YW1wKToKKyAgICAgICAgKFdU Ujo6RXZlbnRTZW5kZXJQcm94eTo6bW91c2VEb3duKToKKyAgICAgICAgKFdUUjo6RXZlbnRTZW5k ZXJQcm94eTo6bW91c2VVcCk6CisgICAgICAgIChXVFI6OkV2ZW50U2VuZGVyUHJveHk6Om1vdXNl TW92ZVRvKToKKyAgICAgICAgKFdUUjo6RXZlbnRTZW5kZXJQcm94eTo6bW91c2VTY3JvbGxCeSk6 CisgICAgICAgIChXVFI6OkV2ZW50U2VuZGVyUHJveHk6OnVwZGF0ZVRvdWNoUG9pbnQpOgorICAg ICAgICAoV1RSOjpFdmVudFNlbmRlclByb3h5OjpwcmVwYXJlQW5kRGlzcGF0Y2hUb3VjaEV2ZW50 KToKKyAgICAgICAgKFdUUjo6RXZlbnRTZW5kZXJQcm94eTo6cmVsZWFzZVRvdWNoUG9pbnQpOgor CiAyMDIwLTA1LTI0ICBTYW0gV2VpbmlnICA8d2VpbmlnQGFwcGxlLmNvbT4KIAogICAgICAgICBF eHRlbmRlZCBDb2xvciBDbGVhbnVwOiBTdG9wIGFsbG93aW5nIGRpcmVjdCBhY2Nlc3MgdG8gdGhl IHVuZGVybHlpbmcgU2ltcGxlQ29sb3IgKGl0IGlzIGFsbW9zdCBhbHdheXMgaW5jb3JyZWN0IHdp dGggcmVzcGVjdCB0byBleHRlbmRlZCBjb2xvcnMpCmRpZmYgLS1naXQgYS9Ub29scy9XZWJLaXRU ZXN0UnVubmVyL3dwZS9FdmVudFNlbmRlclByb3h5V1BFLmNwcCBiL1Rvb2xzL1dlYktpdFRlc3RS dW5uZXIvd3BlL0V2ZW50U2VuZGVyUHJveHlXUEUuY3BwCmluZGV4IDI2MDBiNjgzYzA3NWM5YzEy MDY4ZTdiMmFlMTUyMzRhODA4OGRjMmYuLmUwNDI0NTJmYzY1M2M4OTQyYWFlNGYwZTU3MDhlYTJm MjRiZTUyODcgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvd3BlL0V2ZW50U2Vu ZGVyUHJveHlXUEUuY3BwCisrKyBiL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvd3BlL0V2ZW50U2Vu ZGVyUHJveHlXUEUuY3BwCkBAIC01OCw2ICs1OCwxMSBAQCBzdHJ1Y3Qgd3BlX3ZpZXdfYmFja2Vu ZCogdmlld0JhY2tlbmQoVGVzdENvbnRyb2xsZXImIGNvbnRyb2xsZXIpCiAgICAgcmV0dXJuIGNv bnRyb2xsZXIubWFpbldlYlZpZXcoKS0+cGxhdGZvcm1XaW5kb3coKS0+YmFja2VuZCgpOwogfQog CitzdGF0aWMgdWludDMyX3Qgc2VjVG9Nc1RpbWVzdGFtcChkb3VibGUgY3VycmVudEV2ZW50VGlt ZSkKK3sKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8dWludDMyX3Q+KGN1cnJlbnRFdmVudFRpbWUg KiAxMDAwKTsKK30KKwogRXZlbnRTZW5kZXJQcm94eTo6RXZlbnRTZW5kZXJQcm94eShUZXN0Q29u dHJvbGxlciogdGVzdENvbnRyb2xsZXIpCiAgICAgOiBtX3Rlc3RDb250cm9sbGVyKHRlc3RDb250 cm9sbGVyKQogICAgICwgbV90aW1lKDApCkBAIC0xMzUsNyArMTQwLDcgQEAgdm9pZCBFdmVudFNl bmRlclByb3h5Ojptb3VzZURvd24odW5zaWduZWQgYnV0dG9uLCBXS0V2ZW50TW9kaWZpZXJzIHdr TW9kaWZpZXJzKQogICAgIG1fbW91c2VCdXR0b25zQ3VycmVudGx5RG93biB8PSBtb2RpZmllckZv ckJ1dHRvbih3cGVCdXR0b24pOwogICAgIHVpbnQzMl90IG1vZGlmaWVycyA9IHdrRXZlbnRNb2Rp ZmllcnNUb1dQRSh3a01vZGlmaWVycyk7CiAKLSAgICBzdHJ1Y3Qgd3BlX2lucHV0X3BvaW50ZXJf ZXZlbnQgZXZlbnQgeyB3cGVfaW5wdXRfcG9pbnRlcl9ldmVudF90eXBlX2J1dHRvbiwgc3RhdGlj X2Nhc3Q8dWludDMyX3Q+KG1fdGltZSksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlvbi54KSwg c3RhdGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9uLnkpLCB3cGVCdXR0b24sIG1fYnV0dG9uU3RhdGUs IG1fbW91c2VCdXR0b25zQ3VycmVudGx5RG93biB8IG1vZGlmaWVycyB9OworICAgIHN0cnVjdCB3 cGVfaW5wdXRfcG9pbnRlcl9ldmVudCBldmVudCB7IHdwZV9pbnB1dF9wb2ludGVyX2V2ZW50X3R5 cGVfYnV0dG9uLCBzZWNUb01zVGltZXN0YW1wKG1fdGltZSksIHN0YXRpY19jYXN0PGludD4obV9w b3NpdGlvbi54KSwgc3RhdGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9uLnkpLCB3cGVCdXR0b24sIG1f YnV0dG9uU3RhdGUsIG1fbW91c2VCdXR0b25zQ3VycmVudGx5RG93biB8IG1vZGlmaWVycyB9Owog ICAgIHdwZV92aWV3X2JhY2tlbmRfZGlzcGF0Y2hfcG9pbnRlcl9ldmVudCh2aWV3QmFja2VuZCgq bV90ZXN0Q29udHJvbGxlciksICZldmVudCk7CiB9CiAKQEAgLTE0OCw3ICsxNTMsNyBAQCB2b2lk IEV2ZW50U2VuZGVyUHJveHk6Om1vdXNlVXAodW5zaWduZWQgYnV0dG9uLCBXS0V2ZW50TW9kaWZp ZXJzIHdrTW9kaWZpZXJzKQogICAgIG1fbW91c2VCdXR0b25zQ3VycmVudGx5RG93biAmPSB+bW9k aWZpZXJGb3JCdXR0b24od3BlQnV0dG9uKTsKICAgICB1aW50MzJfdCBtb2RpZmllcnMgPSB3a0V2 ZW50TW9kaWZpZXJzVG9XUEUod2tNb2RpZmllcnMpOwogCi0gICAgc3RydWN0IHdwZV9pbnB1dF9w b2ludGVyX2V2ZW50IGV2ZW50IHsgd3BlX2lucHV0X3BvaW50ZXJfZXZlbnRfdHlwZV9idXR0b24s IHN0YXRpY19jYXN0PHVpbnQzMl90PihtX3RpbWUpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRp b24ueCksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlvbi55KSwgd3BlQnV0dG9uLCBtX2J1dHRv blN0YXRlLCBtX21vdXNlQnV0dG9uc0N1cnJlbnRseURvd24gfCBtb2RpZmllcnMgfTsKKyAgICBz dHJ1Y3Qgd3BlX2lucHV0X3BvaW50ZXJfZXZlbnQgZXZlbnQgeyB3cGVfaW5wdXRfcG9pbnRlcl9l dmVudF90eXBlX2J1dHRvbiwgc2VjVG9Nc1RpbWVzdGFtcChtX3RpbWUpLCBzdGF0aWNfY2FzdDxp bnQ+KG1fcG9zaXRpb24ueCksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlvbi55KSwgd3BlQnV0 dG9uLCBtX2J1dHRvblN0YXRlLCBtX21vdXNlQnV0dG9uc0N1cnJlbnRseURvd24gfCBtb2RpZmll cnMgfTsKICAgICB3cGVfdmlld19iYWNrZW5kX2Rpc3BhdGNoX3BvaW50ZXJfZXZlbnQodmlld0Jh Y2tlbmQoKm1fdGVzdENvbnRyb2xsZXIpLCAmZXZlbnQpOwogfQogCkBAIC0xNTcsNyArMTYyLDcg QEAgdm9pZCBFdmVudFNlbmRlclByb3h5Ojptb3VzZU1vdmVUbyhkb3VibGUgeCwgZG91YmxlIHkp CiAgICAgbV9wb3NpdGlvbi54ID0geDsKICAgICBtX3Bvc2l0aW9uLnkgPSB5OwogCi0gICAgc3Ry dWN0IHdwZV9pbnB1dF9wb2ludGVyX2V2ZW50IGV2ZW50IHsgd3BlX2lucHV0X3BvaW50ZXJfZXZl bnRfdHlwZV9tb3Rpb24sIHN0YXRpY19jYXN0PHVpbnQzMl90PihtX3RpbWUpLCBzdGF0aWNfY2Fz dDxpbnQ+KG1fcG9zaXRpb24ueCksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlvbi55KSwgc3Rh dGljX2Nhc3Q8dWludDMyX3Q+KG1fY2xpY2tCdXR0b24pLCBtX2J1dHRvblN0YXRlLCBtX21vdXNl QnV0dG9uc0N1cnJlbnRseURvd24gfTsKKyAgICBzdHJ1Y3Qgd3BlX2lucHV0X3BvaW50ZXJfZXZl bnQgZXZlbnQgeyB3cGVfaW5wdXRfcG9pbnRlcl9ldmVudF90eXBlX21vdGlvbiwgc2VjVG9Nc1Rp bWVzdGFtcChtX3RpbWUpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueCksIHN0YXRpY19j YXN0PGludD4obV9wb3NpdGlvbi55KSwgc3RhdGljX2Nhc3Q8dWludDMyX3Q+KG1fY2xpY2tCdXR0 b24pLCBtX2J1dHRvblN0YXRlLCBtX21vdXNlQnV0dG9uc0N1cnJlbnRseURvd24gfTsKICAgICB3 cGVfdmlld19iYWNrZW5kX2Rpc3BhdGNoX3BvaW50ZXJfZXZlbnQodmlld0JhY2tlbmQoKm1fdGVz dENvbnRyb2xsZXIpLCAmZXZlbnQpOwogfQogCkBAIC0xNjgsMTEgKzE3MywxMSBAQCB2b2lkIEV2 ZW50U2VuZGVyUHJveHk6Om1vdXNlU2Nyb2xsQnkoaW50IGhvcml6b250YWwsIGludCB2ZXJ0aWNh bCkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKGhvcml6b250YWwpIHsKLSAgICAgICAgc3Ry dWN0IHdwZV9pbnB1dF9heGlzX2V2ZW50IGV2ZW50ID0geyB3cGVfaW5wdXRfYXhpc19ldmVudF90 eXBlX21vdGlvbiwgc3RhdGljX2Nhc3Q8dWludDMyX3Q+KG1fdGltZSksIHN0YXRpY19jYXN0PGlu dD4obV9wb3NpdGlvbi54KSwgc3RhdGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9uLnkpLCBIb3Jpem9u dGFsU2Nyb2xsLCBob3Jpem9udGFsLCAwfTsKKyAgICAgICAgc3RydWN0IHdwZV9pbnB1dF9heGlz X2V2ZW50IGV2ZW50ID0geyB3cGVfaW5wdXRfYXhpc19ldmVudF90eXBlX21vdGlvbiwgc2VjVG9N c1RpbWVzdGFtcChtX3RpbWUpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueCksIHN0YXRp Y19jYXN0PGludD4obV9wb3NpdGlvbi55KSwgSG9yaXpvbnRhbFNjcm9sbCwgaG9yaXpvbnRhbCwg MH07CiAgICAgICAgIHdwZV92aWV3X2JhY2tlbmRfZGlzcGF0Y2hfYXhpc19ldmVudCh2aWV3QmFj a2VuZCgqbV90ZXN0Q29udHJvbGxlciksICZldmVudCk7CiAgICAgfQogICAgIGlmICh2ZXJ0aWNh bCkgewotICAgICAgICBzdHJ1Y3Qgd3BlX2lucHV0X2F4aXNfZXZlbnQgZXZlbnQgPSAgeyB3cGVf aW5wdXRfYXhpc19ldmVudF90eXBlX21vdGlvbiwgc3RhdGljX2Nhc3Q8dWludDMyX3Q+KG1fdGlt ZSksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlvbi54KSwgc3RhdGljX2Nhc3Q8aW50PihtX3Bv c2l0aW9uLnkpLCBWZXJ0aWNhbFNjcm9sbCwgdmVydGljYWwsIDB9OworICAgICAgICBzdHJ1Y3Qg d3BlX2lucHV0X2F4aXNfZXZlbnQgZXZlbnQgPSAgeyB3cGVfaW5wdXRfYXhpc19ldmVudF90eXBl X21vdGlvbiwgc2VjVG9Nc1RpbWVzdGFtcChtX3RpbWUpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9z aXRpb24ueCksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlvbi55KSwgVmVydGljYWxTY3JvbGws IHZlcnRpY2FsLCAwfTsKICAgICAgICAgd3BlX3ZpZXdfYmFja2VuZF9kaXNwYXRjaF9heGlzX2V2 ZW50KHZpZXdCYWNrZW5kKCptX3Rlc3RDb250cm9sbGVyKSwgJmV2ZW50KTsKICAgICB9CiB9CkBA IC0zMjcsNyArMzMyLDcgQEAgdm9pZCBFdmVudFNlbmRlclByb3h5Ojp1cGRhdGVUb3VjaFBvaW50 KGludCBpbmRleCwgaW50IHgsIGludCB5KQogICAgIGF1dG8mIHJhd0V2ZW50ID0gbV90b3VjaEV2 ZW50c1tpbmRleF07CiAgICAgcmF3RXZlbnQueCA9IHg7CiAgICAgcmF3RXZlbnQueSA9IHk7Ci0g ICAgcmF3RXZlbnQudGltZSA9IG1fdGltZTsKKyAgICByYXdFdmVudC50aW1lID0gc2VjVG9Nc1Rp bWVzdGFtcChtX3RpbWUpOwogICAgIHJhd0V2ZW50LnR5cGUgPSB3cGVfaW5wdXRfdG91Y2hfZXZl bnRfdHlwZV9tb3Rpb247CiAgICAgbV91cGRhdGVkVG91Y2hFdmVudHMuYWRkKGluZGV4KTsKIH0K QEAgLTM2Miw3ICszNjcsNyBAQCB2b2lkIEV2ZW50U2VuZGVyUHJveHk6OnJlbW92ZVVwZGF0ZWRU b3VjaEV2ZW50cygpCiB2b2lkIEV2ZW50U2VuZGVyUHJveHk6OnByZXBhcmVBbmREaXNwYXRjaFRv dWNoRXZlbnQoZW51bSB3cGVfaW5wdXRfdG91Y2hfZXZlbnRfdHlwZSBldmVudFR5cGUpCiB7CiAg ICAgYXV0byB1cGRhdGVkRXZlbnRzID0gZ2V0VXBkYXRlZFRvdWNoRXZlbnRzKCk7Ci0gICAgc3Ry dWN0IHdwZV9pbnB1dF90b3VjaF9ldmVudCBldmVudCA9IHsgdXBkYXRlZEV2ZW50cy5kYXRhKCks IHVwZGF0ZWRFdmVudHMuc2l6ZSgpLCBldmVudFR5cGUsIDAsIHN0YXRpY19jYXN0PHVpbnQzMl90 PihtX3RpbWUpLCAwIH07CisgICAgc3RydWN0IHdwZV9pbnB1dF90b3VjaF9ldmVudCBldmVudCA9 IHsgdXBkYXRlZEV2ZW50cy5kYXRhKCksIHVwZGF0ZWRFdmVudHMuc2l6ZSgpLCBldmVudFR5cGUs IDAsIHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKSwgMCB9OwogICAgIHdwZV92aWV3X2JhY2tlbmRf ZGlzcGF0Y2hfdG91Y2hfZXZlbnQodmlld0JhY2tlbmQoKm1fdGVzdENvbnRyb2xsZXIpLCAmZXZl bnQpOwogICAgIGlmIChldmVudFR5cGUgPT0gd3BlX2lucHV0X3RvdWNoX2V2ZW50X3R5cGVfdXAp CiAgICAgICAgIHJlbW92ZVVwZGF0ZWRUb3VjaEV2ZW50cygpOwpAQCAtNDAwLDcgKzQwNSw3IEBA IHZvaWQgRXZlbnRTZW5kZXJQcm94eTo6cmVsZWFzZVRvdWNoUG9pbnQoaW50IGluZGV4KQogICAg IEFTU0VSVChpbmRleCA+PSAwICYmIHN0YXRpY19jYXN0PHNpemVfdD4oaW5kZXgpIDw9IG1fdG91 Y2hFdmVudHMuc2l6ZSgpKTsKIAogICAgIGF1dG8mIHJhd0V2ZW50ID0gbV90b3VjaEV2ZW50c1tp bmRleF07Ci0gICAgcmF3RXZlbnQudGltZSA9IG1fdGltZTsKKyAgICByYXdFdmVudC50aW1lID0g c2VjVG9Nc1RpbWVzdGFtcChtX3RpbWUpOwogICAgIHJhd0V2ZW50LnR5cGUgPSB3cGVfaW5wdXRf dG91Y2hfZXZlbnRfdHlwZV91cDsKICAgICBtX3VwZGF0ZWRUb3VjaEV2ZW50cy5hZGQoaW5kZXgp OwogfQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCmluZGV4IGFkYWE0OTAyZDkyMjIxNDMxNWIyZGZjNDY5ZWRjNDc4OTYwYjQ4NDIuLmM2 MTAwMjVhYmZhYTRhY2ZiN2Q3ZjgwMDJhNzg3MjgyYmNmM2VkZmQgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx NiBAQAorMjAyMC0wNS0yNCAgTGF1cm8gTW91cmEgIDxsbW91cmFAaWdhbGlhLmNvbT4KKworICAg ICAgICBbV1BFXSBBdm9pZCBwb3NzaWJsZSBXVFIgZXZlbnQgdGltaW5nIGdvaW5nIGJhY2sgaW4g dGltZSBhbmQgZml4IGNvbnZlcnNpb24gZnJvbSBzIHRvIG1zCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTIzMzgKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCBuZXcgdGVzdCB0byBjaGVjayBpZiBX UEUgaW5wdXQgZXZlbnRzIHRpbWVzdGFtcHMgYXJlIGFjdHVhbGx5CisgICAgICAgIG1vbm90b25p Y2FsbHkgaW5jcmVhc2luZyBzaW5jZSB0aGUgc3RhcnQuCisKKyAgICAgICAgKiBwbGF0Zm9ybS93 cGUvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUtZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBwbGF0Zm9ybS93cGUvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUu aHRtbDogQWRkZWQuCisKIDIwMjAtMDUtMjQgIFphbGFuIEJ1anRhcyAgPHphbGFuQGFwcGxlLmNv bT4KIAogICAgICAgICBbTEZDXVtURkNdIElnbm9yZSBzZWN0aW9uIGJvcmRlcnMgZXZlbiB3aGVu IGJvcmRlciBjb2xsYXBzZSBpcyBvZmYuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9y bS93cGUvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUtZXhwZWN0ZWQudHh0IGIvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vd3BlL2Zhc3QvZXZlbnRzL21vbm90b25pYy1ldmVudC10aW1lLWV4 cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jM2FkMWVlMDZmMjVlYzM2ZmMwY2E0ZjY1ZDY5NTUyZTdi ODQ3MjI5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd3BlL2Zhc3Qv ZXZlbnRzL21vbm90b25pYy1ldmVudC10aW1lLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEzIEBA CitUaGlzIHRlc3QgY2hlY2tzIGlmIFdQRSBldmVudCB0aW1lc3RhbXBzIGFyZSBtb25vdG9uaWNh bGx5IGluY3JlYXNpbmcgd2hlbiBsZWFwaW5nIGZvcndhcmQuCisKK09uIHN1Y2Nlc3MsIHlvdSB3 aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENP TVBMRVRFIi4KKworCitQQVNTIGxhc3RUaW1lU3RhbXAgPCBldmVudC50aW1lU3RhbXAgaXMgdHJ1 ZQorUEFTUyBsYXN0VGltZVN0YW1wIDwgZXZlbnQudGltZVN0YW1wIGlzIHRydWUKK1BBU1MgbGFz dFRpbWVTdGFtcCA8IGV2ZW50LnRpbWVTdGFtcCBpcyB0cnVlCitQQVNTIGxhc3RUaW1lU3RhbXAg PCBldmVudC50aW1lU3RhbXAgaXMgdHJ1ZQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1 ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3dw ZS9mYXN0L2V2ZW50cy9tb25vdG9uaWMtZXZlbnQtdGltZS5odG1sIGIvTGF5b3V0VGVzdHMvcGxh dGZvcm0vd3BlL2Zhc3QvZXZlbnRzL21vbm90b25pYy1ldmVudC10aW1lLmh0bWwKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uYWUwZGYyNjg4M2UyNDdhY2IzN2VjZDgzYTliZGU1MmUxMWNhZjdhMwotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3dwZS9mYXN0L2V2ZW50cy9tb25vdG9uaWMtZXZl bnQtdGltZS5odG1sCkBAIC0wLDAgKzEsNDUgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8 aGVhZD4KKzxzY3JpcHQgc3JjPSIuLi8uLi8uLi8uLi9yZXNvdXJjZXMvanMtdGVzdC5qcyI+PC9z Y3JpcHQ+Cis8c2NyaXB0PgorCit2YXIgbGFzdFRpbWVTdGFtcCA9IHVuZGVmaW5lZDsKKworZnVu Y3Rpb24gbW91c2VEb3duKGV2ZW50KQoreworICAgIGlmICh0eXBlb2YobGFzdFRpbWVTdGFtcCkg IT0gJ3VuZGVmaW5lZCcpIHsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCdsYXN0VGltZVN0YW1wIDwg ZXZlbnQudGltZVN0YW1wJyk7CisgICAgfQorICAgIGxhc3RUaW1lU3RhbXAgPSBldmVudC50aW1l U3RhbXA7Cit9CisKK2Z1bmN0aW9uIHRlc3QoKQoreworICAgIGRlc2NyaXB0aW9uKGBUaGlzIHRl c3QgY2hlY2tzIGlmIFdQRSBldmVudCB0aW1lc3RhbXBzIGFyZSBtb25vdG9uaWNhbGx5CisgICAg aW5jcmVhc2luZyB3aGVuIGxlYXBpbmcgZm9yd2FyZC5gKTsKKworICAgIGlmICh3aW5kb3cuZXZl bnRTZW5kZXIpIHsKKyAgICAgICAgdmFyIHRlc3RFbGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgidGFyZ2V0Iik7CisgICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKHRlc3RFbGUub2Zm c2V0TGVmdCt0ZXN0RWxlLm9mZnNldFdpZHRoLzIsIHRlc3RFbGUub2Zmc2V0VG9wK3Rlc3RFbGUu b2Zmc2V0SGVpZ2h0LzIpOworICAgICAgICAgICAgdGVzdENsaWNrKCk7CisgICAgfSBlbHNlIGlm ICh3aW5kb3cudGVzdFJ1bm5lcikgeworICAgICAgICB0ZXN0RmFpbGVkKCdUaGlzIHRlc3QgcmVx dWlyZXMgZXZlbnRTZW5kZXInKTsKKyAgICB9Cit9CisKK2Z1bmN0aW9uIHRlc3RDbGljaygpCit7 CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgICAgZm9yICh2YXIgaSA9IDE7IGkgPCA1 OyBpKyspIHsKKyAgICAgICAgZXZlbnRTZW5kZXIubGVhcEZvcndhcmQoMTAwMCk7CisgICAgICAg IGV2ZW50U2VuZGVyLm1vdXNlRG93bigpOworICAgIH0KK30KKzwvc2NyaXB0PgorPC9oZWFkPgor PGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorCis8ZGl2IGlkPSJ0YXJnZXQiIHN0eWxlPSJ3aWR0aDog MTAwcHg7IGhlaWdodDogMTAwcHg7IGJhY2tncm91bmQ6IHJlZDsiIG9ubW91c2Vkb3duPSJtb3Vz ZURvd24oZXZlbnQpIj48L2Rpdj4KKzwvYm9keT4KKzwvaHRtbD4K 400303 2020-05-26 20:15:29 -0700 2020-05-27 12:01:27 -0700 Updated patch initializing m_time to MonotonicTime::now bug-212338-20200527001528.patch text/plain 13821 lmoura U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyMTMzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDdmN2RlOGQ2ODg0ZWQzN2Ex MmY2OGVjOTY3MTA2NTY2MDE3YTAwMzAuLjExZGNiODM0ZTI5NjcxOGY4YmE4NmY1N2Y4ZThhYmYy MzY5ZTYxMzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMjAtMDUtMjUgIExhdXJvIE1v dXJhICA8bG1vdXJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQRV0gQXZvaWQgcG9zc2libGUg V1RSIGV2ZW50IHRpbWluZyBnb2luZyBiYWNrIGluIHRpbWUgYW5kIGZpeCBjb252ZXJzaW9uIGZy b20gcyB0byBtcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjEyMzM4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTWljaGFlbCBDYXRhbnphcm8uCisKKyAg ICAgICAgV2hlbiBjb252ZXJ0aW5nIHRoZSBpbnB1dCB0aW1lc3RhbXBzIHRvIFdhbGxUaW1lLCB3 ZSBtdXN0IHNvbWVob3cKKyAgICAgICAgYWRqdXN0IHRoZW0gdG8gZ2l2ZSBtZWFuaW5nZnVsIHRp bWVzdGFtcHMgKGR1ZSB0byBEb206OkV2ZW50CisgICAgICAgIGNvbnZlcnNpb24gZnJvbSB0aW1l c3RhbXAgd2FsbCB0aW1lIHRvIHRoZSB0aW1lIG9yaWdpbiBmcm9tIGRvY3VtZW50CisgICAgICAg IGxvYWRpbmcpLgorCisgICAgICAgIEFzIFdQRSB0aW1lc3RhbXBzIGFyZSBqdXN0IGludGVuZGVk IHRvIGJlIGNvbXBhcmVkIGFtb25nIHRoZW1zZWx2ZXMsCisgICAgICAgIHdlIHVzZSB0aGUgZmly c3QgcHJvY2Vzc2VkIGV2ZW50IGFzIHRoZSBvcmlnaW4sIGNvbXBhcmluZyB0aGUKKyAgICAgICAg Zm9sbG93aW5nIGV2ZW50cyB0byBpdCB0byBnZXQgYW4gYWN0dWFsIHRpbWUuCisKKyAgICAgICAg VGVzdDogZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUuaHRtbAorCisgICAgICAgICog U2hhcmVkL2xpYndwZS9XZWJFdmVudEZhY3RvcnkuY3BwOgorICAgICAgICAoV2ViS2l0Ojp3YWxs VGltZUZvckV2ZW50VGltZSk6CisKIDIwMjAtMDUtMjUgIEFsZXggQ2hyaXN0ZW5zZW4gIDxhY2hy aXN0ZW5zZW5Ad2Via2l0Lm9yZz4KIAogICAgICAgICBFeHBvc2UgbW9yZSBuZXR3b3JrIG1ldHJp Y3MgdG8gV2ViQ29yZU5TVVJMU2Vzc2lvbgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFy ZWQvbGlid3BlL1dlYkV2ZW50RmFjdG9yeS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9saWJ3 cGUvV2ViRXZlbnRGYWN0b3J5LmNwcAppbmRleCA2MTU1NjI1OTdlZGUyZGU1OGU3Y2M3MzVjZGUz ODQxMDMwOTcyNzI4Li41OWZjYjBhZTk5MWYyYTQ1OGE5YWU5NTM1OWIwYzdhNTgwMmFmZmNhIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9saWJ3cGUvV2ViRXZlbnRGYWN0b3J5LmNw cAorKysgYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9saWJ3cGUvV2ViRXZlbnRGYWN0b3J5LmNwcApA QCAtNTIsMTQgKzUyLDI1IEBAIHN0YXRpYyBPcHRpb25TZXQ8V2ViRXZlbnQ6Ok1vZGlmaWVyPiBt b2RpZmllcnNGb3JFdmVudE1vZGlmaWVycyh1bnNpZ25lZCBldmVudE1vCiAgICAgcmV0dXJuIG1v ZGlmaWVyczsKIH0KIAotV2FsbFRpbWUgd2FsbFRpbWVGb3JFdmVudFRpbWUodWludDY0X3QgdGlt ZXN0YW1wKQorV2FsbFRpbWUgd2FsbFRpbWVGb3JFdmVudFRpbWUodWludDY0X3QgbXNUaW1lU3Rh bXApCiB7Ci0gICAgLy8gVGhpcyB3b3JrcyBpZiBhbmQgb25seSBpZiB0aGUgV1BFIGJhY2tlbmQg dXNlcyBDTE9DS19NT05PVE9OSUMgZm9yIGl0cwotICAgIC8vIGV2ZW50IHRpbWVzdGFtcHMsIGFu ZCBzbyBsb25nIGFzIGdfZ2V0X21vbm90b25pY190aW1lKCkgY29udGludWVzIHRvIGRvCi0gICAg Ly8gc28gYXMgd2VsbCwgYW5kIHNvIGxvbmcgYXMgV1RGOjpNb25vdG9uaWNUaW1lIGNvbnRpbnVl cyB0byB1c2UKLSAgICAvLyBnX2dldF9tb25vdG9uaWNfdGltZSgpLiBJdCBhbHNvIGFzc3VtZXMg dGhlIGV2ZW50IHRpbWVzdGFtcCBpcyBpbgotICAgIC8vIG1pbGxpc2Vjb25kcy4KLSAgICByZXR1 cm4gdGltZXN0YW1wID8gTW9ub3RvbmljVGltZTo6ZnJvbVJhd1NlY29uZHModGltZXN0YW1wIC8g MTAwMC4pLmFwcHJveGltYXRlV2FsbFRpbWUoKSA6IFdhbGxUaW1lOjpub3coKTsKKyAgICAvLyBX UEUgZXZlbnQgdGltZSBmaWVsZCBpcyBhbiB1aW50MzJfdCwgdG9vIHNtYWxsIGZvciBmdWxsIG1z IHRpbWVzdGFtcHMgc2luY2UKKyAgICAvLyB0aGUgZXBvY2gsIGFuZCBhcmUgZXhwZWN0ZWQgdG8g YmUganVzdCB0aW1lc3RhbXBzIHdpdGggbW9ub3RvbmljIGJlaGF2aW9yCisgICAgLy8gdG8gYmUg Y29tcGFyZWQgYW1vbmcgdGhlbXNlbHZlcywgbm90IGFnYWluc3QgV2FsbFRpbWUtbGlrZSBtZWFz dXJlbWVudHMuCisgICAgLy8gVGh1cyB0aGUgbmVlZCB0byBkZWZpbmUgYSByZWZlcmVuY2Ugb3Jp Z2luIGJhc2VkIG9uIHRoZSBmaXJzdCBldmVudCByZWNlaXZlZC4KKworICAgIHN0YXRpYyB1aW50 NjRfdCBmaXJzdEV2ZW50VGltZVN0YW1wOworICAgIHN0YXRpYyBXYWxsVGltZSBmaXJzdEV2ZW50 V2FsbFRpbWU7CisgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIG9uY2U7CisKKyAgICBzdGQ6OmNh bGxfb25jZShvbmNlLCBbbXNUaW1lU3RhbXBdKCkgeworICAgICAgICBmaXJzdEV2ZW50VGltZVN0 YW1wID0gbXNUaW1lU3RhbXA7CisgICAgICAgIGZpcnN0RXZlbnRXYWxsVGltZSA9IFdhbGxUaW1l Ojpub3coKTsKKyAgICB9KTsKKworICAgIHVpbnQ2NF90IGRlbHRhID0gbXNUaW1lU3RhbXAgLSBm aXJzdEV2ZW50VGltZVN0YW1wOworCisgICAgcmV0dXJuIGZpcnN0RXZlbnRXYWxsVGltZSArIFNl Y29uZHMoZGVsdGEgLyAxMDAwLik7CiB9CiAKIFdlYktleWJvYXJkRXZlbnQgV2ViRXZlbnRGYWN0 b3J5OjpjcmVhdGVXZWJLZXlib2FyZEV2ZW50KHN0cnVjdCB3cGVfaW5wdXRfa2V5Ym9hcmRfZXZl bnQqIGV2ZW50LCBjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wgaGFuZGxlZEJ5SW5wdXRNZXRob2Qs IE9wdGlvbmFsPFZlY3RvcjxXZWJDb3JlOjpDb21wb3NpdGlvblVuZGVybGluZT4+JiYgcHJlZWRp dFVuZGVybGluZXMsIE9wdGlvbmFsPEVkaXRpbmdSYW5nZT4mJiBwcmVlZGl0U2VsZWN0aW9uUmFu Z2UpCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXgg OGUwZjExMTNjYmJkNGY3N2NhNTVjYWI2YWI4ZmEwNGQ5YzUxOGFhMS4uYTBkMzE1ZWZmMGJlODE0 MmUwMzkzMzk3ZTFhZWUxNDJlMjJiZjRiZCAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisr KyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIwLTA1LTI1ICBMYXVybyBN b3VyYSAgPGxtb3VyYUBpZ2FsaWEuY29tPgorCisgICAgICAgIFtXUEVdIEF2b2lkIHBvc3NpYmxl IFdUUiBldmVudCB0aW1pbmcgZ29pbmcgYmFjayBpbiB0aW1lIGFuZCBmaXggY29udmVyc2lvbiBm cm9tIHMgdG8gbXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIxMjMzOAorCisgICAgICAgIFJldmlld2VkIGJ5IE1pY2hhZWwgQ2F0YW56YXJvLgorCisg ICAgICAgIE1ha2Ugc3VyZSB3ZSBjYXN0IHRoZSBkb3VibGUgbV90aW1lIHRpbWVzdGFtcCBmcm9t IHNlY29uZHMgdG8gdWludDMyX3QKKyAgICAgICAgbWlsbGlzZWNvbmRzIGV4cGVjdGVkIGJ5IFdQ RSBpbnB1dCBldmVudHMuCisKKyAgICAgICAgKiBXZWJLaXRUZXN0UnVubmVyL3dwZS9FdmVudFNl bmRlclByb3h5V1BFLmNwcDoKKyAgICAgICAgKFdUUjo6c2VjVG9Nc1RpbWVzdGFtcCk6CisgICAg ICAgIChXVFI6OkV2ZW50U2VuZGVyUHJveHk6OkV2ZW50U2VuZGVyUHJveHkpOiBVc2UgbW9ub3Rv bmljIHRpbWUgaW5zdGVhZAorICAgICAgICBvZiB6ZXJvIGFzIHRoZSB0aW1lIG9yaWdpbi4gVGhp cyBpcyB1c2VkIG9ubHkgaW4gYSByZWxhdGl2ZSBtYW5uZXIsCisgICAgICAgIGFuZCB3ZSBuZWVk IG1vbm90b25pYyBiZWhhdmlvciBzbyBjb252ZXJzaW9uIHRvIERPTSBldmVudCB0aW1lc3RhbXBz CisgICAgICAgIG1ha2VzIHNlbnNlLgorICAgICAgICAoV1RSOjpFdmVudFNlbmRlclByb3h5Ojpt b3VzZURvd24pOgorICAgICAgICAoV1RSOjpFdmVudFNlbmRlclByb3h5Ojptb3VzZVVwKToKKyAg ICAgICAgKFdUUjo6RXZlbnRTZW5kZXJQcm94eTo6bW91c2VNb3ZlVG8pOgorICAgICAgICAoV1RS OjpFdmVudFNlbmRlclByb3h5Ojptb3VzZVNjcm9sbEJ5KToKKyAgICAgICAgKFdUUjo6RXZlbnRT ZW5kZXJQcm94eTo6dXBkYXRlVG91Y2hQb2ludCk6CisgICAgICAgIChXVFI6OkV2ZW50U2VuZGVy UHJveHk6OnByZXBhcmVBbmREaXNwYXRjaFRvdWNoRXZlbnQpOgorICAgICAgICAoV1RSOjpFdmVu dFNlbmRlclByb3h5OjpyZWxlYXNlVG91Y2hQb2ludCk6CisKIDIwMjAtMDUtMjQgIFNhbSBXZWlu aWcgIDx3ZWluaWdAYXBwbGUuY29tPgogCiAgICAgICAgIEV4dGVuZGVkIENvbG9yIENsZWFudXA6 IFVzZSB0aGUgbmFtZSBTaW1wbGVDb2xvciBjb25zaXN0ZW50bHkKZGlmZiAtLWdpdCBhL1Rvb2xz L1dlYktpdFRlc3RSdW5uZXIvd3BlL0V2ZW50U2VuZGVyUHJveHlXUEUuY3BwIGIvVG9vbHMvV2Vi S2l0VGVzdFJ1bm5lci93cGUvRXZlbnRTZW5kZXJQcm94eVdQRS5jcHAKaW5kZXggYzRiMTkxNWJh NzMxMDk0ZmZkODBkMDRjOTljYjUzYzg3MzI0Zjc2OC4uZWIxYWFhZGI5ZWUzNWNkOTYzNmZhMzJk Yjc3ZDY4NWRiMzcyMDM2ZCAxMDA2NDQKLS0tIGEvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci93cGUv RXZlbnRTZW5kZXJQcm94eVdQRS5jcHAKKysrIGIvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci93cGUv RXZlbnRTZW5kZXJQcm94eVdQRS5jcHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJUZXN0 Q29udHJvbGxlci5oIgogI2luY2x1ZGUgPFdlYkNvcmUvTm90SW1wbGVtZW50ZWQuaD4KICNpbmNs dWRlIDx3cGUvd3BlLmg+CisjaW5jbHVkZSA8d3RmL01vbm90b25pY1RpbWUuaD4KICNpbmNsdWRl IDx3dGYvVW5pcXVlQXJyYXkuaD4KIAogbmFtZXNwYWNlIFdUUiB7CkBAIC01OCw5ICs1OSwxNiBA QCBzdHJ1Y3Qgd3BlX3ZpZXdfYmFja2VuZCogdmlld0JhY2tlbmQoVGVzdENvbnRyb2xsZXImIGNv bnRyb2xsZXIpCiAgICAgcmV0dXJuIGNvbnRyb2xsZXIubWFpbldlYlZpZXcoKS0+cGxhdGZvcm1X aW5kb3coKS0+YmFja2VuZCgpOwogfQogCitzdGF0aWMgdWludDMyX3Qgc2VjVG9Nc1RpbWVzdGFt cChkb3VibGUgY3VycmVudEV2ZW50VGltZSkKK3sKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8dWlu dDMyX3Q+KGN1cnJlbnRFdmVudFRpbWUgKiAxMDAwKTsKK30KKwogRXZlbnRTZW5kZXJQcm94eTo6 RXZlbnRTZW5kZXJQcm94eShUZXN0Q29udHJvbGxlciogdGVzdENvbnRyb2xsZXIpCiAgICAgOiBt X3Rlc3RDb250cm9sbGVyKHRlc3RDb250cm9sbGVyKQotICAgICwgbV90aW1lKDApCisgICAgLy8g V1BFIGV2ZW50IHRpbWVzdGFtcHMgYXJlIGp1c3QgTW9ub3RvbmljVGltZSwgbm90IGFjdHVhbCBX YWxsVGltZSwgc28gd2UgY2FuCisgICAgLy8gdXNlIGFueSBwb2ludCBvZiBvcmlnaW4sIGFzIGxv bmcgYXMgd2UgYXJlIGNvbnNpc3RlbnQuCisgICAgLCBtX3RpbWUoTW9ub3RvbmljVGltZTo6bm93 KCkuc2Vjb25kc1NpbmNlRXBvY2goKS52YWx1ZSgpKQogICAgICwgbV9sZWZ0TW91c2VCdXR0b25E b3duKGZhbHNlKQogICAgICwgbV9jbGlja0NvdW50KDApCiAgICAgLCBtX2NsaWNrVGltZSgwKQpA QCAtMTM1LDcgKzE0Myw3IEBAIHZvaWQgRXZlbnRTZW5kZXJQcm94eTo6bW91c2VEb3duKHVuc2ln bmVkIGJ1dHRvbiwgV0tFdmVudE1vZGlmaWVycyB3a01vZGlmaWVycykKICAgICBtX21vdXNlQnV0 dG9uc0N1cnJlbnRseURvd24gfD0gbW9kaWZpZXJGb3JCdXR0b24od3BlQnV0dG9uKTsKICAgICB1 aW50MzJfdCBtb2RpZmllcnMgPSB3a0V2ZW50TW9kaWZpZXJzVG9XUEUod2tNb2RpZmllcnMpOwog Ci0gICAgc3RydWN0IHdwZV9pbnB1dF9wb2ludGVyX2V2ZW50IGV2ZW50IHsgd3BlX2lucHV0X3Bv aW50ZXJfZXZlbnRfdHlwZV9idXR0b24sIHN0YXRpY19jYXN0PHVpbnQzMl90PihtX3RpbWUpLCBz dGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueCksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlv bi55KSwgd3BlQnV0dG9uLCBtX2J1dHRvblN0YXRlLCBtX21vdXNlQnV0dG9uc0N1cnJlbnRseURv d24gfCBtb2RpZmllcnMgfTsKKyAgICBzdHJ1Y3Qgd3BlX2lucHV0X3BvaW50ZXJfZXZlbnQgZXZl bnQgeyB3cGVfaW5wdXRfcG9pbnRlcl9ldmVudF90eXBlX2J1dHRvbiwgc2VjVG9Nc1RpbWVzdGFt cChtX3RpbWUpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueCksIHN0YXRpY19jYXN0PGlu dD4obV9wb3NpdGlvbi55KSwgd3BlQnV0dG9uLCBtX2J1dHRvblN0YXRlLCBtX21vdXNlQnV0dG9u c0N1cnJlbnRseURvd24gfCBtb2RpZmllcnMgfTsKICAgICB3cGVfdmlld19iYWNrZW5kX2Rpc3Bh dGNoX3BvaW50ZXJfZXZlbnQodmlld0JhY2tlbmQoKm1fdGVzdENvbnRyb2xsZXIpLCAmZXZlbnQp OwogfQogCkBAIC0xNDgsNyArMTU2LDcgQEAgdm9pZCBFdmVudFNlbmRlclByb3h5Ojptb3VzZVVw KHVuc2lnbmVkIGJ1dHRvbiwgV0tFdmVudE1vZGlmaWVycyB3a01vZGlmaWVycykKICAgICBtX21v dXNlQnV0dG9uc0N1cnJlbnRseURvd24gJj0gfm1vZGlmaWVyRm9yQnV0dG9uKHdwZUJ1dHRvbik7 CiAgICAgdWludDMyX3QgbW9kaWZpZXJzID0gd2tFdmVudE1vZGlmaWVyc1RvV1BFKHdrTW9kaWZp ZXJzKTsKIAotICAgIHN0cnVjdCB3cGVfaW5wdXRfcG9pbnRlcl9ldmVudCBldmVudCB7IHdwZV9p bnB1dF9wb2ludGVyX2V2ZW50X3R5cGVfYnV0dG9uLCBzdGF0aWNfY2FzdDx1aW50MzJfdD4obV90 aW1lKSwgc3RhdGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9uLngpLCBzdGF0aWNfY2FzdDxpbnQ+KG1f cG9zaXRpb24ueSksIHdwZUJ1dHRvbiwgbV9idXR0b25TdGF0ZSwgbV9tb3VzZUJ1dHRvbnNDdXJy ZW50bHlEb3duIHwgbW9kaWZpZXJzIH07CisgICAgc3RydWN0IHdwZV9pbnB1dF9wb2ludGVyX2V2 ZW50IGV2ZW50IHsgd3BlX2lucHV0X3BvaW50ZXJfZXZlbnRfdHlwZV9idXR0b24sIHNlY1RvTXNU aW1lc3RhbXAobV90aW1lKSwgc3RhdGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9uLngpLCBzdGF0aWNf Y2FzdDxpbnQ+KG1fcG9zaXRpb24ueSksIHdwZUJ1dHRvbiwgbV9idXR0b25TdGF0ZSwgbV9tb3Vz ZUJ1dHRvbnNDdXJyZW50bHlEb3duIHwgbW9kaWZpZXJzIH07CiAgICAgd3BlX3ZpZXdfYmFja2Vu ZF9kaXNwYXRjaF9wb2ludGVyX2V2ZW50KHZpZXdCYWNrZW5kKCptX3Rlc3RDb250cm9sbGVyKSwg JmV2ZW50KTsKIH0KIApAQCAtMTU3LDcgKzE2NSw3IEBAIHZvaWQgRXZlbnRTZW5kZXJQcm94eTo6 bW91c2VNb3ZlVG8oZG91YmxlIHgsIGRvdWJsZSB5KQogICAgIG1fcG9zaXRpb24ueCA9IHg7CiAg ICAgbV9wb3NpdGlvbi55ID0geTsKIAotICAgIHN0cnVjdCB3cGVfaW5wdXRfcG9pbnRlcl9ldmVu dCBldmVudCB7IHdwZV9pbnB1dF9wb2ludGVyX2V2ZW50X3R5cGVfbW90aW9uLCBzdGF0aWNfY2Fz dDx1aW50MzJfdD4obV90aW1lKSwgc3RhdGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9uLngpLCBzdGF0 aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueSksIHN0YXRpY19jYXN0PHVpbnQzMl90PihtX2NsaWNr QnV0dG9uKSwgbV9idXR0b25TdGF0ZSwgbV9tb3VzZUJ1dHRvbnNDdXJyZW50bHlEb3duIH07Cisg ICAgc3RydWN0IHdwZV9pbnB1dF9wb2ludGVyX2V2ZW50IGV2ZW50IHsgd3BlX2lucHV0X3BvaW50 ZXJfZXZlbnRfdHlwZV9tb3Rpb24sIHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKSwgc3RhdGljX2Nh c3Q8aW50PihtX3Bvc2l0aW9uLngpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueSksIHN0 YXRpY19jYXN0PHVpbnQzMl90PihtX2NsaWNrQnV0dG9uKSwgbV9idXR0b25TdGF0ZSwgbV9tb3Vz ZUJ1dHRvbnNDdXJyZW50bHlEb3duIH07CiAgICAgd3BlX3ZpZXdfYmFja2VuZF9kaXNwYXRjaF9w b2ludGVyX2V2ZW50KHZpZXdCYWNrZW5kKCptX3Rlc3RDb250cm9sbGVyKSwgJmV2ZW50KTsKIH0K IApAQCAtMTY4LDExICsxNzYsMTEgQEAgdm9pZCBFdmVudFNlbmRlclByb3h5Ojptb3VzZVNjcm9s bEJ5KGludCBob3Jpem9udGFsLCBpbnQgdmVydGljYWwpCiAgICAgICAgIHJldHVybjsKIAogICAg IGlmIChob3Jpem9udGFsKSB7Ci0gICAgICAgIHN0cnVjdCB3cGVfaW5wdXRfYXhpc19ldmVudCBl dmVudCA9IHsgd3BlX2lucHV0X2F4aXNfZXZlbnRfdHlwZV9tb3Rpb24sIHN0YXRpY19jYXN0PHVp bnQzMl90PihtX3RpbWUpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueCksIHN0YXRpY19j YXN0PGludD4obV9wb3NpdGlvbi55KSwgSG9yaXpvbnRhbFNjcm9sbCwgaG9yaXpvbnRhbCwgMH07 CisgICAgICAgIHN0cnVjdCB3cGVfaW5wdXRfYXhpc19ldmVudCBldmVudCA9IHsgd3BlX2lucHV0 X2F4aXNfZXZlbnRfdHlwZV9tb3Rpb24sIHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKSwgc3RhdGlj X2Nhc3Q8aW50PihtX3Bvc2l0aW9uLngpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueSks IEhvcml6b250YWxTY3JvbGwsIGhvcml6b250YWwsIDB9OwogICAgICAgICB3cGVfdmlld19iYWNr ZW5kX2Rpc3BhdGNoX2F4aXNfZXZlbnQodmlld0JhY2tlbmQoKm1fdGVzdENvbnRyb2xsZXIpLCAm ZXZlbnQpOwogICAgIH0KICAgICBpZiAodmVydGljYWwpIHsKLSAgICAgICAgc3RydWN0IHdwZV9p bnB1dF9heGlzX2V2ZW50IGV2ZW50ID0gIHsgd3BlX2lucHV0X2F4aXNfZXZlbnRfdHlwZV9tb3Rp b24sIHN0YXRpY19jYXN0PHVpbnQzMl90PihtX3RpbWUpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9z aXRpb24ueCksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlvbi55KSwgVmVydGljYWxTY3JvbGws IHZlcnRpY2FsLCAwfTsKKyAgICAgICAgc3RydWN0IHdwZV9pbnB1dF9heGlzX2V2ZW50IGV2ZW50 ID0gIHsgd3BlX2lucHV0X2F4aXNfZXZlbnRfdHlwZV9tb3Rpb24sIHNlY1RvTXNUaW1lc3RhbXAo bV90aW1lKSwgc3RhdGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9uLngpLCBzdGF0aWNfY2FzdDxpbnQ+ KG1fcG9zaXRpb24ueSksIFZlcnRpY2FsU2Nyb2xsLCB2ZXJ0aWNhbCwgMH07CiAgICAgICAgIHdw ZV92aWV3X2JhY2tlbmRfZGlzcGF0Y2hfYXhpc19ldmVudCh2aWV3QmFja2VuZCgqbV90ZXN0Q29u dHJvbGxlciksICZldmVudCk7CiAgICAgfQogfQpAQCAtMzI3LDcgKzMzNSw3IEBAIHZvaWQgRXZl bnRTZW5kZXJQcm94eTo6dXBkYXRlVG91Y2hQb2ludChpbnQgaW5kZXgsIGludCB4LCBpbnQgeSkK ICAgICBhdXRvJiByYXdFdmVudCA9IG1fdG91Y2hFdmVudHNbaW5kZXhdOwogICAgIHJhd0V2ZW50 LnggPSB4OwogICAgIHJhd0V2ZW50LnkgPSB5OwotICAgIHJhd0V2ZW50LnRpbWUgPSBtX3RpbWU7 CisgICAgcmF3RXZlbnQudGltZSA9IHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKTsKICAgICByYXdF dmVudC50eXBlID0gd3BlX2lucHV0X3RvdWNoX2V2ZW50X3R5cGVfbW90aW9uOwogICAgIG1fdXBk YXRlZFRvdWNoRXZlbnRzLmFkZChpbmRleCk7CiB9CkBAIC0zNjIsNyArMzcwLDcgQEAgdm9pZCBF dmVudFNlbmRlclByb3h5OjpyZW1vdmVVcGRhdGVkVG91Y2hFdmVudHMoKQogdm9pZCBFdmVudFNl bmRlclByb3h5OjpwcmVwYXJlQW5kRGlzcGF0Y2hUb3VjaEV2ZW50KGVudW0gd3BlX2lucHV0X3Rv dWNoX2V2ZW50X3R5cGUgZXZlbnRUeXBlKQogewogICAgIGF1dG8gdXBkYXRlZEV2ZW50cyA9IGdl dFVwZGF0ZWRUb3VjaEV2ZW50cygpOwotICAgIHN0cnVjdCB3cGVfaW5wdXRfdG91Y2hfZXZlbnQg ZXZlbnQgPSB7IHVwZGF0ZWRFdmVudHMuZGF0YSgpLCB1cGRhdGVkRXZlbnRzLnNpemUoKSwgZXZl bnRUeXBlLCAwLCBzdGF0aWNfY2FzdDx1aW50MzJfdD4obV90aW1lKSwgMCB9OworICAgIHN0cnVj dCB3cGVfaW5wdXRfdG91Y2hfZXZlbnQgZXZlbnQgPSB7IHVwZGF0ZWRFdmVudHMuZGF0YSgpLCB1 cGRhdGVkRXZlbnRzLnNpemUoKSwgZXZlbnRUeXBlLCAwLCBzZWNUb01zVGltZXN0YW1wKG1fdGlt ZSksIDAgfTsKICAgICB3cGVfdmlld19iYWNrZW5kX2Rpc3BhdGNoX3RvdWNoX2V2ZW50KHZpZXdC YWNrZW5kKCptX3Rlc3RDb250cm9sbGVyKSwgJmV2ZW50KTsKICAgICBpZiAoZXZlbnRUeXBlID09 IHdwZV9pbnB1dF90b3VjaF9ldmVudF90eXBlX3VwKQogICAgICAgICByZW1vdmVVcGRhdGVkVG91 Y2hFdmVudHMoKTsKQEAgLTQwMCw3ICs0MDgsNyBAQCB2b2lkIEV2ZW50U2VuZGVyUHJveHk6OnJl bGVhc2VUb3VjaFBvaW50KGludCBpbmRleCkKICAgICBBU1NFUlQoaW5kZXggPj0gMCAmJiBzdGF0 aWNfY2FzdDxzaXplX3Q+KGluZGV4KSA8PSBtX3RvdWNoRXZlbnRzLnNpemUoKSk7CiAKICAgICBh dXRvJiByYXdFdmVudCA9IG1fdG91Y2hFdmVudHNbaW5kZXhdOwotICAgIHJhd0V2ZW50LnRpbWUg PSBtX3RpbWU7CisgICAgcmF3RXZlbnQudGltZSA9IHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKTsK ICAgICByYXdFdmVudC50eXBlID0gd3BlX2lucHV0X3RvdWNoX2V2ZW50X3R5cGVfdXA7CiAgICAg bV91cGRhdGVkVG91Y2hFdmVudHMuYWRkKGluZGV4KTsKIH0KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA4ZDhiODQ3MDNkNzc4 NjA2ZjM2YTkzY2JiZTM2OWQ5YjQ4MjMwYzM0Li45NTYzMmNmNGRlYTQzYzk1ODgyMWQ4MzRhZjRm ZjIyNTc5OTE1NzIwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMjAtMDUtMjUgIExhdXJvIE1v dXJhICA8bG1vdXJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQRV0gQXZvaWQgcG9zc2libGUg V1RSIGV2ZW50IHRpbWluZyBnb2luZyBiYWNrIGluIHRpbWUgYW5kIGZpeCBjb252ZXJzaW9uIGZy b20gcyB0byBtcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjEyMzM4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTWljaGFlbCBDYXRhbnphcm8uCisKKyAg ICAgICAgQWRkZWQgbmV3IHRlc3QgdG8gY2hlY2sgaWYgaW5wdXQgZXZlbnRzIHRpbWVzdGFtcHMg YXJlIGFjdHVhbGx5CisgICAgICAgIG1vbm90b25pY2FsbHkgaW5jcmVhc2luZyBzaW5jZSB0aGUg c3RhcnQuCisKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9tb25vdG9uaWMtZXZlbnQtdGltZS1leHBl Y3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL21vbm90b25pYy1ldmVudC10 aW1lLmh0bWw6IEFkZGVkLgorCiAyMDIwLTA1LTI1ICBPcmlvbCBCcnVmYXUgIDxvYnJ1ZmF1QGln YWxpYS5jb20+CiAKICAgICAgICAgW2Nzcy1ncmlkXSBQcmV2ZW50IGdyaWQtdGVtcGxhdGUtcm93 cyBmcm9tIHNlcmlhbGl6aW5nIGFkamFjZW50IDxsaW5lLW5hbWVzPgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUtZXhwZWN0ZWQudHh0IGIv TGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUtZXhwZWN0ZWQudHh0 Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmIxYWY2MzM5MDYzMjRlZDhkYjY3OGM1OGM4NzFmZmZkOWQ3NDAwN2IKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9tb25vdG9uaWMtZXZlbnQt dGltZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMyBAQAorVGhpcyB0ZXN0IGNoZWNrcyBpZiBE T00gZXZlbnQgdGltZXN0YW1wcyBhcmUgbW9ub3RvbmljYWxseSBpbmNyZWFzaW5nIHdoZW4gbGVh cGluZyBmb3J3YXJkLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBB U1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUEFTUyBsYXN0 VGltZVN0YW1wIDwgZXZlbnQudGltZVN0YW1wIGlzIHRydWUKK1BBU1MgbGFzdFRpbWVTdGFtcCA8 IGV2ZW50LnRpbWVTdGFtcCBpcyB0cnVlCitQQVNTIGxhc3RUaW1lU3RhbXAgPCBldmVudC50aW1l U3RhbXAgaXMgdHJ1ZQorUEFTUyBsYXN0VGltZVN0YW1wIDwgZXZlbnQudGltZVN0YW1wIGlzIHRy dWUKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9tb25vdG9uaWMtZXZlbnQtdGltZS5o dG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi45MWVmNjIxZDdjYzYxNzE3MDlmZDUxYjY2MTIwNDNkYmI4NTAwNWNkCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRp bWUuaHRtbApAQCAtMCwwICsxLDQ3IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+ Cis8c2NyaXB0IHNyYz0iLi4vLi4vcmVzb3VyY2VzL2pzLXRlc3QuanMiPjwvc2NyaXB0PgorPHNj cmlwdD4KKwordmFyIGxhc3RUaW1lU3RhbXAgPSB1bmRlZmluZWQ7CisKK2Z1bmN0aW9uIG1vdXNl RG93bihldmVudCkKK3sKKyAgICBpZiAodHlwZW9mKGxhc3RUaW1lU3RhbXApICE9ICd1bmRlZmlu ZWQnKSB7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgnbGFzdFRpbWVTdGFtcCA8IGV2ZW50LnRpbWVT dGFtcCcpOworICAgIH0KKyAgICBsYXN0VGltZVN0YW1wID0gZXZlbnQudGltZVN0YW1wOworfQor CitmdW5jdGlvbiB0ZXN0KCkKK3sKKyAgICBkZXNjcmlwdGlvbihgVGhpcyB0ZXN0IGNoZWNrcyBp ZiBET00gZXZlbnQgdGltZXN0YW1wcyBhcmUgbW9ub3RvbmljYWxseQorICAgIGluY3JlYXNpbmcg d2hlbiBsZWFwaW5nIGZvcndhcmQuYCk7CisKKyAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyKSB7 CisgICAgICAgIHZhciB0ZXN0RWxlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIp OworICAgICAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh0ZXN0RWxlLm9mZnNldExlZnQrdGVz dEVsZS5vZmZzZXRXaWR0aC8yLCB0ZXN0RWxlLm9mZnNldFRvcCt0ZXN0RWxlLm9mZnNldEhlaWdo dC8yKTsKKyAgICAgICAgdGVzdENsaWNrKCk7CisgICAgfSBlbHNlIGlmICh3aW5kb3cudGVzdFJ1 bm5lcikgeworICAgICAgICB0ZXN0RmFpbGVkKCdUaGlzIHRlc3QgcmVxdWlyZXMgZXZlbnRTZW5k ZXInKTsKKyAgICB9Cit9CisKK2Z1bmN0aW9uIHRlc3RDbGljaygpCit7CisgICAgZXZlbnRTZW5k ZXIubW91c2VEb3duKCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworICAgIGZvciAodmFy IGkgPSAxOyBpIDwgNTsgaSsrKSB7CisgICAgICAgIGV2ZW50U2VuZGVyLmxlYXBGb3J3YXJkKDEw MDApOworICAgICAgICBldmVudFNlbmRlci5tb3VzZURvd24oKTsKKyAgICAgICAgZXZlbnRTZW5k ZXIubW91c2VVcCgpOworICAgIH0KK30KKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHkgb25sb2Fk PSJ0ZXN0KCkiPgorCis8ZGl2IGlkPSJ0YXJnZXQiIHN0eWxlPSJ3aWR0aDogMTAwcHg7IGhlaWdo dDogMTAwcHg7IGJhY2tncm91bmQ6IHJlZDsiIG9ubW91c2Vkb3duPSJtb3VzZURvd24oZXZlbnQp Ij48L2Rpdj4KKzwvYm9keT4KKzwvaHRtbD4K 400363 2020-05-27 12:01:32 -0700 2020-05-27 13:45:48 -0700 Patch for landing bug-212338-20200527160131.patch text/plain 14664 lmoura U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyMjA0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDk4NWFjZGRlNjhhODA2OWE0 OTVmNDI2MDM3NGY2YmNhYzYzY2YzNGIuLmYwYzJhNjI5Y2Q2M2QxOThmOTRkYTJhZWMwYWY5ZWIz ZjIyNzlkZWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMjAtMDUtMjcgIExhdXJvIE1v dXJhICA8bG1vdXJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQRV0gQXZvaWQgcG9zc2libGUg V1RSIGV2ZW50IHRpbWluZyBnb2luZyBiYWNrIGluIHRpbWUgYW5kIGZpeCBjb252ZXJzaW9uIGZy b20gcyB0byBtcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjEyMzM4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTWljaGFlbCBDYXRhbnphcm8uCisKKyAg ICAgICAgV2hlbiBjb252ZXJ0aW5nIHRoZSBpbnB1dCB0aW1lc3RhbXBzIHRvIFdhbGxUaW1lLCB3 ZSBtdXN0IHNvbWVob3cKKyAgICAgICAgYWRqdXN0IHRoZW0gdG8gZ2l2ZSBtZWFuaW5nZnVsIHRp bWVzdGFtcHMgKGR1ZSB0byBEb206OkV2ZW50CisgICAgICAgIGNvbnZlcnNpb24gZnJvbSB0aW1l c3RhbXAgd2FsbCB0aW1lIHRvIHRoZSB0aW1lIG9yaWdpbiBmcm9tIGRvY3VtZW50CisgICAgICAg IGxvYWRpbmcpLgorCisgICAgICAgIEFzIFdQRSB0aW1lc3RhbXBzIGFyZSBqdXN0IGludGVuZGVk IHRvIGJlIGNvbXBhcmVkIGFtb25nIHRoZW1zZWx2ZXMsCisgICAgICAgIHdlIHVzZSB0aGUgZmly c3QgcHJvY2Vzc2VkIGV2ZW50IGFzIHRoZSBvcmlnaW4sIGNvbXBhcmluZyB0aGUKKyAgICAgICAg Zm9sbG93aW5nIGV2ZW50cyB0byBpdCB0byBnZXQgYW4gYWN0dWFsIHRpbWUuCisKKyAgICAgICAg VGVzdDogZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUuaHRtbAorCisgICAgICAgICog U2hhcmVkL2xpYndwZS9XZWJFdmVudEZhY3RvcnkuY3BwOgorICAgICAgICAoV2ViS2l0Ojp3YWxs VGltZUZvckV2ZW50VGltZSk6CisKIDIwMjAtMDUtMjcgIEJyZW50IEZ1bGdoYW0gIDxiZnVsZ2hh bUBhcHBsZS5jb20+CiAKICAgICAgICAgQWRqdXN0IEhUVFAzIGxhYmVsIHRvIHRoZSBtb3JlIGNv cnJlY3QgSFRUUC8zCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9saWJ3cGUvV2Vi RXZlbnRGYWN0b3J5LmNwcCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL2xpYndwZS9XZWJFdmVudEZh Y3RvcnkuY3BwCmluZGV4IDYxNTU2MjU5N2VkZTJkZTU4ZTdjYzczNWNkZTM4NDEwMzA5NzI3Mjgu LjU5ZmNiMGFlOTkxZjJhNDU4YTlhZTk1MzU5YjBjN2E1ODAyYWZmY2EgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvU2hhcmVkL2xpYndwZS9XZWJFdmVudEZhY3RvcnkuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQvU2hhcmVkL2xpYndwZS9XZWJFdmVudEZhY3RvcnkuY3BwCkBAIC01MiwxNCArNTIs MjUgQEAgc3RhdGljIE9wdGlvblNldDxXZWJFdmVudDo6TW9kaWZpZXI+IG1vZGlmaWVyc0ZvckV2 ZW50TW9kaWZpZXJzKHVuc2lnbmVkIGV2ZW50TW8KICAgICByZXR1cm4gbW9kaWZpZXJzOwogfQog Ci1XYWxsVGltZSB3YWxsVGltZUZvckV2ZW50VGltZSh1aW50NjRfdCB0aW1lc3RhbXApCitXYWxs VGltZSB3YWxsVGltZUZvckV2ZW50VGltZSh1aW50NjRfdCBtc1RpbWVTdGFtcCkKIHsKLSAgICAv LyBUaGlzIHdvcmtzIGlmIGFuZCBvbmx5IGlmIHRoZSBXUEUgYmFja2VuZCB1c2VzIENMT0NLX01P Tk9UT05JQyBmb3IgaXRzCi0gICAgLy8gZXZlbnQgdGltZXN0YW1wcywgYW5kIHNvIGxvbmcgYXMg Z19nZXRfbW9ub3RvbmljX3RpbWUoKSBjb250aW51ZXMgdG8gZG8KLSAgICAvLyBzbyBhcyB3ZWxs LCBhbmQgc28gbG9uZyBhcyBXVEY6Ok1vbm90b25pY1RpbWUgY29udGludWVzIHRvIHVzZQotICAg IC8vIGdfZ2V0X21vbm90b25pY190aW1lKCkuIEl0IGFsc28gYXNzdW1lcyB0aGUgZXZlbnQgdGlt ZXN0YW1wIGlzIGluCi0gICAgLy8gbWlsbGlzZWNvbmRzLgotICAgIHJldHVybiB0aW1lc3RhbXAg PyBNb25vdG9uaWNUaW1lOjpmcm9tUmF3U2Vjb25kcyh0aW1lc3RhbXAgLyAxMDAwLikuYXBwcm94 aW1hdGVXYWxsVGltZSgpIDogV2FsbFRpbWU6Om5vdygpOworICAgIC8vIFdQRSBldmVudCB0aW1l IGZpZWxkIGlzIGFuIHVpbnQzMl90LCB0b28gc21hbGwgZm9yIGZ1bGwgbXMgdGltZXN0YW1wcyBz aW5jZQorICAgIC8vIHRoZSBlcG9jaCwgYW5kIGFyZSBleHBlY3RlZCB0byBiZSBqdXN0IHRpbWVz dGFtcHMgd2l0aCBtb25vdG9uaWMgYmVoYXZpb3IKKyAgICAvLyB0byBiZSBjb21wYXJlZCBhbW9u ZyB0aGVtc2VsdmVzLCBub3QgYWdhaW5zdCBXYWxsVGltZS1saWtlIG1lYXN1cmVtZW50cy4KKyAg ICAvLyBUaHVzIHRoZSBuZWVkIHRvIGRlZmluZSBhIHJlZmVyZW5jZSBvcmlnaW4gYmFzZWQgb24g dGhlIGZpcnN0IGV2ZW50IHJlY2VpdmVkLgorCisgICAgc3RhdGljIHVpbnQ2NF90IGZpcnN0RXZl bnRUaW1lU3RhbXA7CisgICAgc3RhdGljIFdhbGxUaW1lIGZpcnN0RXZlbnRXYWxsVGltZTsKKyAg ICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25jZTsKKworICAgIHN0ZDo6Y2FsbF9vbmNlKG9uY2Us IFttc1RpbWVTdGFtcF0oKSB7CisgICAgICAgIGZpcnN0RXZlbnRUaW1lU3RhbXAgPSBtc1RpbWVT dGFtcDsKKyAgICAgICAgZmlyc3RFdmVudFdhbGxUaW1lID0gV2FsbFRpbWU6Om5vdygpOworICAg IH0pOworCisgICAgdWludDY0X3QgZGVsdGEgPSBtc1RpbWVTdGFtcCAtIGZpcnN0RXZlbnRUaW1l U3RhbXA7CisKKyAgICByZXR1cm4gZmlyc3RFdmVudFdhbGxUaW1lICsgU2Vjb25kcyhkZWx0YSAv IDEwMDAuKTsKIH0KIAogV2ViS2V5Ym9hcmRFdmVudCBXZWJFdmVudEZhY3Rvcnk6OmNyZWF0ZVdl YktleWJvYXJkRXZlbnQoc3RydWN0IHdwZV9pbnB1dF9rZXlib2FyZF9ldmVudCogZXZlbnQsIGNv bnN0IFN0cmluZyYgdGV4dCwgYm9vbCBoYW5kbGVkQnlJbnB1dE1ldGhvZCwgT3B0aW9uYWw8VmVj dG9yPFdlYkNvcmU6OkNvbXBvc2l0aW9uVW5kZXJsaW5lPj4mJiBwcmVlZGl0VW5kZXJsaW5lcywg T3B0aW9uYWw8RWRpdGluZ1JhbmdlPiYmIHByZWVkaXRTZWxlY3Rpb25SYW5nZSkKZGlmZiAtLWdp dCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBjMzgwMGNiNDZiODY1 ZTNjNzRjZDI0MzgxYzUxZjMxNGUwMWEyNjcyLi5mNjVhMDI3OTEzYTk1ODNjZmFlY2ZjMjJiYzM0 NGMwZTM5NDZjZGY1IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjcgQEAKKzIwMjAtMDUtMjcgIExhdXJvIE1vdXJhICA8bG1vdXJh QGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQRV0gQXZvaWQgcG9zc2libGUgV1RSIGV2ZW50IHRp bWluZyBnb2luZyBiYWNrIGluIHRpbWUgYW5kIGZpeCBjb252ZXJzaW9uIGZyb20gcyB0byBtcwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyMzM4CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTWljaGFlbCBDYXRhbnphcm8uCisKKyAgICAgICAgTWFrZSBz dXJlIHdlIGNhc3QgdGhlIGRvdWJsZSBtX3RpbWUgdGltZXN0YW1wIGZyb20gc2Vjb25kcyB0byB1 aW50MzJfdAorICAgICAgICBtaWxsaXNlY29uZHMgZXhwZWN0ZWQgYnkgV1BFIGlucHV0IGV2ZW50 cy4KKworICAgICAgICAqIFdlYktpdFRlc3RSdW5uZXIvd3BlL0V2ZW50U2VuZGVyUHJveHlXUEUu Y3BwOgorICAgICAgICAoV1RSOjpzZWNUb01zVGltZXN0YW1wKToKKyAgICAgICAgKFdUUjo6RXZl bnRTZW5kZXJQcm94eTo6RXZlbnRTZW5kZXJQcm94eSk6IFVzZSBtb25vdG9uaWMgdGltZSBpbnN0 ZWFkCisgICAgICAgIG9mIHplcm8gYXMgdGhlIHRpbWUgb3JpZ2luLiBUaGlzIGlzIHVzZWQgb25s eSBpbiBhIHJlbGF0aXZlIG1hbm5lciwKKyAgICAgICAgYW5kIHdlIG5lZWQgbW9ub3RvbmljIGJl aGF2aW9yIHNvIGNvbnZlcnNpb24gdG8gRE9NIGV2ZW50IHRpbWVzdGFtcHMKKyAgICAgICAgbWFr ZXMgc2Vuc2UuCisgICAgICAgIChXVFI6OkV2ZW50U2VuZGVyUHJveHk6Om1vdXNlRG93bik6Cisg ICAgICAgIChXVFI6OkV2ZW50U2VuZGVyUHJveHk6Om1vdXNlVXApOgorICAgICAgICAoV1RSOjpF dmVudFNlbmRlclByb3h5Ojptb3VzZU1vdmVUbyk6CisgICAgICAgIChXVFI6OkV2ZW50U2VuZGVy UHJveHk6Om1vdXNlU2Nyb2xsQnkpOgorICAgICAgICAoV1RSOjpFdmVudFNlbmRlclByb3h5Ojp1 cGRhdGVUb3VjaFBvaW50KToKKyAgICAgICAgKFdUUjo6RXZlbnRTZW5kZXJQcm94eTo6cHJlcGFy ZUFuZERpc3BhdGNoVG91Y2hFdmVudCk6CisgICAgICAgIChXVFI6OkV2ZW50U2VuZGVyUHJveHk6 OnJlbGVhc2VUb3VjaFBvaW50KToKKwogMjAyMC0wNS0yNyAgRGV2aW4gUm91c3NvICA8ZHJvdXNz b0BhcHBsZS5jb20+CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogcmVwbGFjZSBgZmVhdHVyZUd1 YXJkYCBhbmQgYGF2YWlsYWJpbGl0eWAgd2l0aCBhIGNvbWJpbmVkIGBjb25kaXRpb25gIHRoYXQg YWNjZXB0cyBhbnkgbWFjcm8KZGlmZiAtLWdpdCBhL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvd3Bl L0V2ZW50U2VuZGVyUHJveHlXUEUuY3BwIGIvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci93cGUvRXZl bnRTZW5kZXJQcm94eVdQRS5jcHAKaW5kZXggYzRiMTkxNWJhNzMxMDk0ZmZkODBkMDRjOTljYjUz Yzg3MzI0Zjc2OC4uZWIxYWFhZGI5ZWUzNWNkOTYzNmZhMzJkYjc3ZDY4NWRiMzcyMDM2ZCAxMDA2 NDQKLS0tIGEvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci93cGUvRXZlbnRTZW5kZXJQcm94eVdQRS5j cHAKKysrIGIvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci93cGUvRXZlbnRTZW5kZXJQcm94eVdQRS5j cHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJUZXN0Q29udHJvbGxlci5oIgogI2luY2x1 ZGUgPFdlYkNvcmUvTm90SW1wbGVtZW50ZWQuaD4KICNpbmNsdWRlIDx3cGUvd3BlLmg+CisjaW5j bHVkZSA8d3RmL01vbm90b25pY1RpbWUuaD4KICNpbmNsdWRlIDx3dGYvVW5pcXVlQXJyYXkuaD4K IAogbmFtZXNwYWNlIFdUUiB7CkBAIC01OCw5ICs1OSwxNiBAQCBzdHJ1Y3Qgd3BlX3ZpZXdfYmFj a2VuZCogdmlld0JhY2tlbmQoVGVzdENvbnRyb2xsZXImIGNvbnRyb2xsZXIpCiAgICAgcmV0dXJu IGNvbnRyb2xsZXIubWFpbldlYlZpZXcoKS0+cGxhdGZvcm1XaW5kb3coKS0+YmFja2VuZCgpOwog fQogCitzdGF0aWMgdWludDMyX3Qgc2VjVG9Nc1RpbWVzdGFtcChkb3VibGUgY3VycmVudEV2ZW50 VGltZSkKK3sKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8dWludDMyX3Q+KGN1cnJlbnRFdmVudFRp bWUgKiAxMDAwKTsKK30KKwogRXZlbnRTZW5kZXJQcm94eTo6RXZlbnRTZW5kZXJQcm94eShUZXN0 Q29udHJvbGxlciogdGVzdENvbnRyb2xsZXIpCiAgICAgOiBtX3Rlc3RDb250cm9sbGVyKHRlc3RD b250cm9sbGVyKQotICAgICwgbV90aW1lKDApCisgICAgLy8gV1BFIGV2ZW50IHRpbWVzdGFtcHMg YXJlIGp1c3QgTW9ub3RvbmljVGltZSwgbm90IGFjdHVhbCBXYWxsVGltZSwgc28gd2UgY2FuCisg ICAgLy8gdXNlIGFueSBwb2ludCBvZiBvcmlnaW4sIGFzIGxvbmcgYXMgd2UgYXJlIGNvbnNpc3Rl bnQuCisgICAgLCBtX3RpbWUoTW9ub3RvbmljVGltZTo6bm93KCkuc2Vjb25kc1NpbmNlRXBvY2go KS52YWx1ZSgpKQogICAgICwgbV9sZWZ0TW91c2VCdXR0b25Eb3duKGZhbHNlKQogICAgICwgbV9j bGlja0NvdW50KDApCiAgICAgLCBtX2NsaWNrVGltZSgwKQpAQCAtMTM1LDcgKzE0Myw3IEBAIHZv aWQgRXZlbnRTZW5kZXJQcm94eTo6bW91c2VEb3duKHVuc2lnbmVkIGJ1dHRvbiwgV0tFdmVudE1v ZGlmaWVycyB3a01vZGlmaWVycykKICAgICBtX21vdXNlQnV0dG9uc0N1cnJlbnRseURvd24gfD0g bW9kaWZpZXJGb3JCdXR0b24od3BlQnV0dG9uKTsKICAgICB1aW50MzJfdCBtb2RpZmllcnMgPSB3 a0V2ZW50TW9kaWZpZXJzVG9XUEUod2tNb2RpZmllcnMpOwogCi0gICAgc3RydWN0IHdwZV9pbnB1 dF9wb2ludGVyX2V2ZW50IGV2ZW50IHsgd3BlX2lucHV0X3BvaW50ZXJfZXZlbnRfdHlwZV9idXR0 b24sIHN0YXRpY19jYXN0PHVpbnQzMl90PihtX3RpbWUpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9z aXRpb24ueCksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlvbi55KSwgd3BlQnV0dG9uLCBtX2J1 dHRvblN0YXRlLCBtX21vdXNlQnV0dG9uc0N1cnJlbnRseURvd24gfCBtb2RpZmllcnMgfTsKKyAg ICBzdHJ1Y3Qgd3BlX2lucHV0X3BvaW50ZXJfZXZlbnQgZXZlbnQgeyB3cGVfaW5wdXRfcG9pbnRl cl9ldmVudF90eXBlX2J1dHRvbiwgc2VjVG9Nc1RpbWVzdGFtcChtX3RpbWUpLCBzdGF0aWNfY2Fz dDxpbnQ+KG1fcG9zaXRpb24ueCksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlvbi55KSwgd3Bl QnV0dG9uLCBtX2J1dHRvblN0YXRlLCBtX21vdXNlQnV0dG9uc0N1cnJlbnRseURvd24gfCBtb2Rp ZmllcnMgfTsKICAgICB3cGVfdmlld19iYWNrZW5kX2Rpc3BhdGNoX3BvaW50ZXJfZXZlbnQodmll d0JhY2tlbmQoKm1fdGVzdENvbnRyb2xsZXIpLCAmZXZlbnQpOwogfQogCkBAIC0xNDgsNyArMTU2 LDcgQEAgdm9pZCBFdmVudFNlbmRlclByb3h5Ojptb3VzZVVwKHVuc2lnbmVkIGJ1dHRvbiwgV0tF dmVudE1vZGlmaWVycyB3a01vZGlmaWVycykKICAgICBtX21vdXNlQnV0dG9uc0N1cnJlbnRseURv d24gJj0gfm1vZGlmaWVyRm9yQnV0dG9uKHdwZUJ1dHRvbik7CiAgICAgdWludDMyX3QgbW9kaWZp ZXJzID0gd2tFdmVudE1vZGlmaWVyc1RvV1BFKHdrTW9kaWZpZXJzKTsKIAotICAgIHN0cnVjdCB3 cGVfaW5wdXRfcG9pbnRlcl9ldmVudCBldmVudCB7IHdwZV9pbnB1dF9wb2ludGVyX2V2ZW50X3R5 cGVfYnV0dG9uLCBzdGF0aWNfY2FzdDx1aW50MzJfdD4obV90aW1lKSwgc3RhdGljX2Nhc3Q8aW50 PihtX3Bvc2l0aW9uLngpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueSksIHdwZUJ1dHRv biwgbV9idXR0b25TdGF0ZSwgbV9tb3VzZUJ1dHRvbnNDdXJyZW50bHlEb3duIHwgbW9kaWZpZXJz IH07CisgICAgc3RydWN0IHdwZV9pbnB1dF9wb2ludGVyX2V2ZW50IGV2ZW50IHsgd3BlX2lucHV0 X3BvaW50ZXJfZXZlbnRfdHlwZV9idXR0b24sIHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKSwgc3Rh dGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9uLngpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24u eSksIHdwZUJ1dHRvbiwgbV9idXR0b25TdGF0ZSwgbV9tb3VzZUJ1dHRvbnNDdXJyZW50bHlEb3du IHwgbW9kaWZpZXJzIH07CiAgICAgd3BlX3ZpZXdfYmFja2VuZF9kaXNwYXRjaF9wb2ludGVyX2V2 ZW50KHZpZXdCYWNrZW5kKCptX3Rlc3RDb250cm9sbGVyKSwgJmV2ZW50KTsKIH0KIApAQCAtMTU3 LDcgKzE2NSw3IEBAIHZvaWQgRXZlbnRTZW5kZXJQcm94eTo6bW91c2VNb3ZlVG8oZG91YmxlIHgs IGRvdWJsZSB5KQogICAgIG1fcG9zaXRpb24ueCA9IHg7CiAgICAgbV9wb3NpdGlvbi55ID0geTsK IAotICAgIHN0cnVjdCB3cGVfaW5wdXRfcG9pbnRlcl9ldmVudCBldmVudCB7IHdwZV9pbnB1dF9w b2ludGVyX2V2ZW50X3R5cGVfbW90aW9uLCBzdGF0aWNfY2FzdDx1aW50MzJfdD4obV90aW1lKSwg c3RhdGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9uLngpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRp b24ueSksIHN0YXRpY19jYXN0PHVpbnQzMl90PihtX2NsaWNrQnV0dG9uKSwgbV9idXR0b25TdGF0 ZSwgbV9tb3VzZUJ1dHRvbnNDdXJyZW50bHlEb3duIH07CisgICAgc3RydWN0IHdwZV9pbnB1dF9w b2ludGVyX2V2ZW50IGV2ZW50IHsgd3BlX2lucHV0X3BvaW50ZXJfZXZlbnRfdHlwZV9tb3Rpb24s IHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKSwgc3RhdGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9uLngp LCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueSksIHN0YXRpY19jYXN0PHVpbnQzMl90Piht X2NsaWNrQnV0dG9uKSwgbV9idXR0b25TdGF0ZSwgbV9tb3VzZUJ1dHRvbnNDdXJyZW50bHlEb3du IH07CiAgICAgd3BlX3ZpZXdfYmFja2VuZF9kaXNwYXRjaF9wb2ludGVyX2V2ZW50KHZpZXdCYWNr ZW5kKCptX3Rlc3RDb250cm9sbGVyKSwgJmV2ZW50KTsKIH0KIApAQCAtMTY4LDExICsxNzYsMTEg QEAgdm9pZCBFdmVudFNlbmRlclByb3h5Ojptb3VzZVNjcm9sbEJ5KGludCBob3Jpem9udGFsLCBp bnQgdmVydGljYWwpCiAgICAgICAgIHJldHVybjsKIAogICAgIGlmIChob3Jpem9udGFsKSB7Ci0g ICAgICAgIHN0cnVjdCB3cGVfaW5wdXRfYXhpc19ldmVudCBldmVudCA9IHsgd3BlX2lucHV0X2F4 aXNfZXZlbnRfdHlwZV9tb3Rpb24sIHN0YXRpY19jYXN0PHVpbnQzMl90PihtX3RpbWUpLCBzdGF0 aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueCksIHN0YXRpY19jYXN0PGludD4obV9wb3NpdGlvbi55 KSwgSG9yaXpvbnRhbFNjcm9sbCwgaG9yaXpvbnRhbCwgMH07CisgICAgICAgIHN0cnVjdCB3cGVf aW5wdXRfYXhpc19ldmVudCBldmVudCA9IHsgd3BlX2lucHV0X2F4aXNfZXZlbnRfdHlwZV9tb3Rp b24sIHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKSwgc3RhdGljX2Nhc3Q8aW50PihtX3Bvc2l0aW9u LngpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueSksIEhvcml6b250YWxTY3JvbGwsIGhv cml6b250YWwsIDB9OwogICAgICAgICB3cGVfdmlld19iYWNrZW5kX2Rpc3BhdGNoX2F4aXNfZXZl bnQodmlld0JhY2tlbmQoKm1fdGVzdENvbnRyb2xsZXIpLCAmZXZlbnQpOwogICAgIH0KICAgICBp ZiAodmVydGljYWwpIHsKLSAgICAgICAgc3RydWN0IHdwZV9pbnB1dF9heGlzX2V2ZW50IGV2ZW50 ID0gIHsgd3BlX2lucHV0X2F4aXNfZXZlbnRfdHlwZV9tb3Rpb24sIHN0YXRpY19jYXN0PHVpbnQz Ml90PihtX3RpbWUpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueCksIHN0YXRpY19jYXN0 PGludD4obV9wb3NpdGlvbi55KSwgVmVydGljYWxTY3JvbGwsIHZlcnRpY2FsLCAwfTsKKyAgICAg ICAgc3RydWN0IHdwZV9pbnB1dF9heGlzX2V2ZW50IGV2ZW50ID0gIHsgd3BlX2lucHV0X2F4aXNf ZXZlbnRfdHlwZV9tb3Rpb24sIHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKSwgc3RhdGljX2Nhc3Q8 aW50PihtX3Bvc2l0aW9uLngpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fcG9zaXRpb24ueSksIFZlcnRp Y2FsU2Nyb2xsLCB2ZXJ0aWNhbCwgMH07CiAgICAgICAgIHdwZV92aWV3X2JhY2tlbmRfZGlzcGF0 Y2hfYXhpc19ldmVudCh2aWV3QmFja2VuZCgqbV90ZXN0Q29udHJvbGxlciksICZldmVudCk7CiAg ICAgfQogfQpAQCAtMzI3LDcgKzMzNSw3IEBAIHZvaWQgRXZlbnRTZW5kZXJQcm94eTo6dXBkYXRl VG91Y2hQb2ludChpbnQgaW5kZXgsIGludCB4LCBpbnQgeSkKICAgICBhdXRvJiByYXdFdmVudCA9 IG1fdG91Y2hFdmVudHNbaW5kZXhdOwogICAgIHJhd0V2ZW50LnggPSB4OwogICAgIHJhd0V2ZW50 LnkgPSB5OwotICAgIHJhd0V2ZW50LnRpbWUgPSBtX3RpbWU7CisgICAgcmF3RXZlbnQudGltZSA9 IHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKTsKICAgICByYXdFdmVudC50eXBlID0gd3BlX2lucHV0 X3RvdWNoX2V2ZW50X3R5cGVfbW90aW9uOwogICAgIG1fdXBkYXRlZFRvdWNoRXZlbnRzLmFkZChp bmRleCk7CiB9CkBAIC0zNjIsNyArMzcwLDcgQEAgdm9pZCBFdmVudFNlbmRlclByb3h5OjpyZW1v dmVVcGRhdGVkVG91Y2hFdmVudHMoKQogdm9pZCBFdmVudFNlbmRlclByb3h5OjpwcmVwYXJlQW5k RGlzcGF0Y2hUb3VjaEV2ZW50KGVudW0gd3BlX2lucHV0X3RvdWNoX2V2ZW50X3R5cGUgZXZlbnRU eXBlKQogewogICAgIGF1dG8gdXBkYXRlZEV2ZW50cyA9IGdldFVwZGF0ZWRUb3VjaEV2ZW50cygp OwotICAgIHN0cnVjdCB3cGVfaW5wdXRfdG91Y2hfZXZlbnQgZXZlbnQgPSB7IHVwZGF0ZWRFdmVu dHMuZGF0YSgpLCB1cGRhdGVkRXZlbnRzLnNpemUoKSwgZXZlbnRUeXBlLCAwLCBzdGF0aWNfY2Fz dDx1aW50MzJfdD4obV90aW1lKSwgMCB9OworICAgIHN0cnVjdCB3cGVfaW5wdXRfdG91Y2hfZXZl bnQgZXZlbnQgPSB7IHVwZGF0ZWRFdmVudHMuZGF0YSgpLCB1cGRhdGVkRXZlbnRzLnNpemUoKSwg ZXZlbnRUeXBlLCAwLCBzZWNUb01zVGltZXN0YW1wKG1fdGltZSksIDAgfTsKICAgICB3cGVfdmll d19iYWNrZW5kX2Rpc3BhdGNoX3RvdWNoX2V2ZW50KHZpZXdCYWNrZW5kKCptX3Rlc3RDb250cm9s bGVyKSwgJmV2ZW50KTsKICAgICBpZiAoZXZlbnRUeXBlID09IHdwZV9pbnB1dF90b3VjaF9ldmVu dF90eXBlX3VwKQogICAgICAgICByZW1vdmVVcGRhdGVkVG91Y2hFdmVudHMoKTsKQEAgLTQwMCw3 ICs0MDgsNyBAQCB2b2lkIEV2ZW50U2VuZGVyUHJveHk6OnJlbGVhc2VUb3VjaFBvaW50KGludCBp bmRleCkKICAgICBBU1NFUlQoaW5kZXggPj0gMCAmJiBzdGF0aWNfY2FzdDxzaXplX3Q+KGluZGV4 KSA8PSBtX3RvdWNoRXZlbnRzLnNpemUoKSk7CiAKICAgICBhdXRvJiByYXdFdmVudCA9IG1fdG91 Y2hFdmVudHNbaW5kZXhdOwotICAgIHJhd0V2ZW50LnRpbWUgPSBtX3RpbWU7CisgICAgcmF3RXZl bnQudGltZSA9IHNlY1RvTXNUaW1lc3RhbXAobV90aW1lKTsKICAgICByYXdFdmVudC50eXBlID0g d3BlX2lucHV0X3RvdWNoX2V2ZW50X3R5cGVfdXA7CiAgICAgbV91cGRhdGVkVG91Y2hFdmVudHMu YWRkKGluZGV4KTsKIH0KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91 dFRlc3RzL0NoYW5nZUxvZwppbmRleCBiYTUzZmJjZWYxZTIwOTFiM2I0NTc2MjExNzJiMWI4NmI0 YjE4YzA4Li44ZDg2NjY5NWY1NjAzNDE4MjBiZWFjNDk3OTQ3NzQyNTNkYzc5Zjc1IDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTggQEAKKzIwMjAtMDUtMjcgIExhdXJvIE1vdXJhICA8bG1vdXJhQGlnYWxpYS5j b20+CisKKyAgICAgICAgW1dQRV0gQXZvaWQgcG9zc2libGUgV1RSIGV2ZW50IHRpbWluZyBnb2lu ZyBiYWNrIGluIHRpbWUgYW5kIGZpeCBjb252ZXJzaW9uIGZyb20gcyB0byBtcworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyMzM4CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTWljaGFlbCBDYXRhbnphcm8uCisKKyAgICAgICAgQWRkZWQgbmV3IHRlc3Qg dG8gY2hlY2sgaWYgaW5wdXQgZXZlbnRzIHRpbWVzdGFtcHMgYXJlIGFjdHVhbGx5CisgICAgICAg IG1vbm90b25pY2FsbHkgaW5jcmVhc2luZyBzaW5jZSB0aGUgc3RhcnQuCisKKyAgICAgICAgKiBm YXN0L2V2ZW50cy9tb25vdG9uaWMtZXZlbnQtdGltZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIGZhc3QvZXZlbnRzL21vbm90b25pYy1ldmVudC10aW1lLmh0bWw6IEFkZGVkLgorICAg ICAgICAqIHBsYXRmb3JtL2lvcy9UZXN0RXhwZWN0YXRpb25zOiBTa2lwcGVkIHRoZSB0ZXN0IGFz IGl0IHJlbGllcyBvbgorICAgICAgICBtb3VzZURvd24KKwogMjAyMC0wNS0yNyAgUnlhbiBIYWRk YWQgIDxyeWFuaGFkZGFkQGFwcGxlLmNvbT4KIAogICAgICAgICBbIG1hY09TIF0gaHR0cC90ZXN0 cy9tZWRpYS9ub3ctcGxheWluZy1pbmZvLmh0bWwgaXMgZmxha3kgZmFpbGluZwpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUtZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUtZXhwZWN0 ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmIxYWY2MzM5MDYzMjRlZDhkYjY3OGM1OGM4NzFmZmZkOWQ3NDAw N2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9tb25vdG9uaWMt ZXZlbnQtdGltZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMyBAQAorVGhpcyB0ZXN0IGNoZWNr cyBpZiBET00gZXZlbnQgdGltZXN0YW1wcyBhcmUgbW9ub3RvbmljYWxseSBpbmNyZWFzaW5nIHdo ZW4gbGVhcGluZyBmb3J3YXJkLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMg b2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUEFT UyBsYXN0VGltZVN0YW1wIDwgZXZlbnQudGltZVN0YW1wIGlzIHRydWUKK1BBU1MgbGFzdFRpbWVT dGFtcCA8IGV2ZW50LnRpbWVTdGFtcCBpcyB0cnVlCitQQVNTIGxhc3RUaW1lU3RhbXAgPCBldmVu dC50aW1lU3RhbXAgaXMgdHJ1ZQorUEFTUyBsYXN0VGltZVN0YW1wIDwgZXZlbnQudGltZVN0YW1w IGlzIHRydWUKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVU RQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9tb25vdG9uaWMtZXZlbnQt dGltZS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2ZW50LXRpbWUu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi45MWVmNjIxZDdjYzYxNzE3MDlmZDUxYjY2MTIwNDNkYmI4NTAwNWNk Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvbW9ub3RvbmljLWV2 ZW50LXRpbWUuaHRtbApAQCAtMCwwICsxLDQ3IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgor PGhlYWQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vcmVzb3VyY2VzL2pzLXRlc3QuanMiPjwvc2NyaXB0 PgorPHNjcmlwdD4KKwordmFyIGxhc3RUaW1lU3RhbXAgPSB1bmRlZmluZWQ7CisKK2Z1bmN0aW9u IG1vdXNlRG93bihldmVudCkKK3sKKyAgICBpZiAodHlwZW9mKGxhc3RUaW1lU3RhbXApICE9ICd1 bmRlZmluZWQnKSB7CisgICAgICAgIHNob3VsZEJlVHJ1ZSgnbGFzdFRpbWVTdGFtcCA8IGV2ZW50 LnRpbWVTdGFtcCcpOworICAgIH0KKyAgICBsYXN0VGltZVN0YW1wID0gZXZlbnQudGltZVN0YW1w OworfQorCitmdW5jdGlvbiB0ZXN0KCkKK3sKKyAgICBkZXNjcmlwdGlvbihgVGhpcyB0ZXN0IGNo ZWNrcyBpZiBET00gZXZlbnQgdGltZXN0YW1wcyBhcmUgbW9ub3RvbmljYWxseQorICAgIGluY3Jl YXNpbmcgd2hlbiBsZWFwaW5nIGZvcndhcmQuYCk7CisKKyAgICBpZiAod2luZG93LmV2ZW50U2Vu ZGVyKSB7CisgICAgICAgIHZhciB0ZXN0RWxlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRh cmdldCIpOworICAgICAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh0ZXN0RWxlLm9mZnNldExl ZnQrdGVzdEVsZS5vZmZzZXRXaWR0aC8yLCB0ZXN0RWxlLm9mZnNldFRvcCt0ZXN0RWxlLm9mZnNl dEhlaWdodC8yKTsKKyAgICAgICAgdGVzdENsaWNrKCk7CisgICAgfSBlbHNlIGlmICh3aW5kb3cu dGVzdFJ1bm5lcikgeworICAgICAgICB0ZXN0RmFpbGVkKCdUaGlzIHRlc3QgcmVxdWlyZXMgZXZl bnRTZW5kZXInKTsKKyAgICB9Cit9CisKK2Z1bmN0aW9uIHRlc3RDbGljaygpCit7CisgICAgZXZl bnRTZW5kZXIubW91c2VEb3duKCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworICAgIGZv ciAodmFyIGkgPSAxOyBpIDwgNTsgaSsrKSB7CisgICAgICAgIGV2ZW50U2VuZGVyLmxlYXBGb3J3 YXJkKDEwMDApOworICAgICAgICBldmVudFNlbmRlci5tb3VzZURvd24oKTsKKyAgICAgICAgZXZl bnRTZW5kZXIubW91c2VVcCgpOworICAgIH0KK30KKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHkg b25sb2FkPSJ0ZXN0KCkiPgorCis8ZGl2IGlkPSJ0YXJnZXQiIHN0eWxlPSJ3aWR0aDogMTAwcHg7 IGhlaWdodDogMTAwcHg7IGJhY2tncm91bmQ6IHJlZDsiIG9ubW91c2Vkb3duPSJtb3VzZURvd24o ZXZlbnQpIj48L2Rpdj4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L3BsYXRmb3JtL2lvcy9UZXN0RXhwZWN0YXRpb25zIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9z L1Rlc3RFeHBlY3RhdGlvbnMKaW5kZXggYjJkMzBkZDRhZGNlODVhNzZmYTZmNDE4ZWRjOTA1MTI5 MmQ1ZjBlZS4uNDBjYWY1YTYwMmRlYzdlMTk2Y2EyODNhYjI4MGE0ZTg5Y2E0ZmQzNiAxMDA2NDQK LS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zL1Rlc3RFeHBlY3RhdGlvbnMKKysrIGIvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vaW9zL1Rlc3RFeHBlY3RhdGlvbnMKQEAgLTQ4MCw2ICs0ODAsNyBA QCBmYXN0L2V2ZW50cy9pbnB1dC1ldmVudHMtZHJhZy1hbmQtZHJvcC5odG1sIFsgU2tpcCBdCiBm YXN0L2V2ZW50cy9pbnB1dC1ldmVudHMtaW5zZXJ0LWJ5LWRyb3AuaHRtbCBbIFNraXAgXQogZmFz dC9ldmVudHMvaW5wdXQtaW1hZ2Utc2Nyb2xsZWQteC15Lmh0bWwgWyBTa2lwIF0KIGZhc3QvZXZl bnRzL2tleWRvd24tMS5odG1sIFsgU2tpcCBdCitmYXN0L2V2ZW50cy9tb25vdG9uaWMtZXZlbnQt dGltZS5odG1sIFsgU2tpcCBdCiBmYXN0L2V2ZW50cy9tb3N1ZWRyYWctb24tY2FudmFzLXNob3Vs ZC1ub3Qtc3RhcnQtc2VsZWN0aW9uLmh0bWwgWyBTa2lwIF0KIGZhc3QvZXZlbnRzL21vdXNlLWNs aWNrLWV2ZW50cy5odG1sIFsgU2tpcCBdCiBmYXN0L2V2ZW50cy9tb3VzZS1jdXJzb3ItY2hhbmdl Lmh0bWwgWyBTa2lwIF0K