196705 2019-04-08 14:11:02 -0700 Background tabs are not fully reactivated after a link is opened from an external application 2019-04-10 09:32:38 -0700 1 1 1 Unclassified WebKit WebKit Misc. WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 beidson beidson achristensen cdumez commit-queue ggaren oldest_to_newest 1525355 0 beidson 2019-04-08 14:11:02 -0700 Background tabs are not fully reactivated after a link is opened from an external application <rdar://problem/49533278> 1525360 1 366979 beidson 2019-04-08 14:17:51 -0700 Created attachment 366979 Patch 1525398 2 366979 ggaren 2019-04-08 14:52:24 -0700 Comment on attachment 366979 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=366979&action=review > Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm:79 > + if (_lastTrackedApplicationState == LastTrackedApplicationState::Background) > + [self _applicationWillEnterForeground]; What happens if we enter a window while the application is background? (Seems wrong to unconditionally foreground the WebView in that case.) 1525408 3 366979 cdumez 2019-04-08 15:03:37 -0700 Comment on attachment 366979 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=366979&action=review >> Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm:79 >> + [self _applicationWillEnterForeground]; > > What happens if we enter a window while the application is background? (Seems wrong to unconditionally foreground the WebView in that case.) Maybe we should also make sure that the UIApplication's applicationState is not UIApplicationStateBackground? 1525437 4 366979 ggaren 2019-04-08 15:56:43 -0700 Comment on attachment 366979 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=366979&action=review Seems like we need to pick one of these ways to fix the "move to window while in the background" logic error. >>> Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm:79 >>> + [self _applicationWillEnterForeground]; >> >> What happens if we enter a window while the application is background? (Seems wrong to unconditionally foreground the WebView in that case.) > > Maybe we should also make sure that the UIApplication's applicationState is not UIApplicationStateBackground? I guess this needs to be... if (_lastTrackedApplicationState == LastTrackedApplicationState::Background && !_applicationStateTracker->isInBackground()) [self _applicationWillEnterForeground]; One bummer about this solution is that ApplicationStateTracker no longer encapsulates the logic for tracking application state. It's partially encapsulated in this view now, even to the point where the view calls its own notification selector on itself. Another option is to change the strategy here. There's no need to delete _applicationStateTracker when we exit the window. Instead, you can keep the _applicationStateTracker, and simply return early from _applicationDidEnterBackground, _applicationDidFinishSnapshottingAfterEnteringBackground, and _applicationWillEnterForeground if the view is not in window. The nice thing about this new strategy is that you avoid splitting application state tracking across two classes. 1525441 5 ggaren 2019-04-08 16:01:10 -0700 Hmmm... I guess either way you need to track the last state you were in or the last update you ignored. 1525473 6 beidson 2019-04-08 17:06:04 -0700 (In reply to Geoffrey Garen from comment #4) > Comment on attachment 366979 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=366979&action=review > > Seems like we need to pick one of these ways to fix the "move to window > while in the background" logic error. > > >>> Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm:79 > >>> + [self _applicationWillEnterForeground]; > >> > >> What happens if we enter a window while the application is background? (Seems wrong to unconditionally foreground the WebView in that case.) > > > > Maybe we should also make sure that the UIApplication's applicationState is not UIApplicationStateBackground? > > I guess this needs to be... > > if (_lastTrackedApplicationState == > LastTrackedApplicationState::Background && > !_applicationStateTracker->isInBackground()) > [self _applicationWillEnterForeground]; > > One bummer about this solution is that ApplicationStateTracker no longer > encapsulates the logic for tracking application state. It's partially > encapsulated in this view now, even to the point where the view calls its > own notification selector on itself. > > Another option is to change the strategy here. There's no need to delete > _applicationStateTracker when we exit the window. Instead, you can keep the > _applicationStateTracker, and simply return early from > _applicationDidEnterBackground, > _applicationDidFinishSnapshottingAfterEnteringBackground, and > _applicationWillEnterForeground if the view is not in window. The nice thing > about this new strategy is that you avoid splitting application state > tracking across two classes. The changes suggested here break things in seemingly subtle ways. E.g. switching between Mail and Safari, now Mail is broken. I'll have to re-add logging and step through carefully to continue pursuing these changes. 1525700 7 367058 beidson 2019-04-09 11:57:01 -0700 Created attachment 367058 Patch 1525769 8 367058 cdumez 2019-04-09 15:00:00 -0700 Comment on attachment 367058 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=367058&action=review > Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm:49 > + _applicationStateTracker = std::make_unique<WebKit::ApplicationStateTracker>(self, @selector(_applicationDidEnterBackground), @selector(_applicationDidFinishSnapshottingAfterEnteringBackground), @selector(_applicationWillEnterForeground)); I do not understand why we're making this particular change. It used to be that only parent views would have an ApplicationStateTracker. Now all views get one and get notified whenever the app goes to background / foreground. Aren't we doing a lot of unnecessary work? Also, even though those unparented views have an applicationState tracker, they seem to return early whenever they get notifications, this seems unfortunate. 1525784 9 beidson 2019-04-09 16:01:10 -0700 (In reply to Chris Dumez from comment #8) > Comment on attachment 367058 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=367058&action=review > > > Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm:49 > > + _applicationStateTracker = std::make_unique<WebKit::ApplicationStateTracker>(self, @selector(_applicationDidEnterBackground), @selector(_applicationDidFinishSnapshottingAfterEnteringBackground), @selector(_applicationWillEnterForeground)); > > I do not understand why we're making this particular change. It used to be > that only parent views would have an ApplicationStateTracker. Now all views > get one and get notified whenever the app goes to background / foreground. > Aren't we doing a lot of unnecessary work? They are getting notified, but they aren't doing any work. > Also, even though those unparented views have an applicationState tracker, > they seem to return early whenever they get notifications, this seems > unfortunate. That's literally the whole point of Geoff's suggestion (and that's how - like I mention above - they aren't doing any work) 1525802 10 cdumez 2019-04-09 16:43:57 -0700 (In reply to Brady Eidson from comment #9) > (In reply to Chris Dumez from comment #8) > > Comment on attachment 367058 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=367058&action=review > > > > > Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm:49 > > > + _applicationStateTracker = std::make_unique<WebKit::ApplicationStateTracker>(self, @selector(_applicationDidEnterBackground), @selector(_applicationDidFinishSnapshottingAfterEnteringBackground), @selector(_applicationWillEnterForeground)); > > > > I do not understand why we're making this particular change. It used to be > > that only parent views would have an ApplicationStateTracker. Now all views > > get one and get notified whenever the app goes to background / foreground. > > Aren't we doing a lot of unnecessary work? > > They are getting notified, but they aren't doing any work. > > > Also, even though those unparented views have an applicationState tracker, > > they seem to return early whenever they get notifications, this seems > > unfortunate. > > That's literally the whole point of Geoff's suggestion (and that's how - > like I mention above - they aren't doing any work) Just because they are returning early does not mean we're not doing any work. There is certainly a cost memory wise and computation wise to having many clients registered for notifications that they actually do not care about. 1525806 11 beidson 2019-04-09 16:48:58 -0700 (In reply to Chris Dumez from comment #10) > (In reply to Brady Eidson from comment #9) > > (In reply to Chris Dumez from comment #8) > > > Comment on attachment 367058 [details] > > > Patch > > > > > > View in context: > > > https://bugs.webkit.org/attachment.cgi?id=367058&action=review > > > > > > > Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm:49 > > > > + _applicationStateTracker = std::make_unique<WebKit::ApplicationStateTracker>(self, @selector(_applicationDidEnterBackground), @selector(_applicationDidFinishSnapshottingAfterEnteringBackground), @selector(_applicationWillEnterForeground)); > > > > > > I do not understand why we're making this particular change. It used to be > > > that only parent views would have an ApplicationStateTracker. Now all views > > > get one and get notified whenever the app goes to background / foreground. > > > Aren't we doing a lot of unnecessary work? > > > > They are getting notified, but they aren't doing any work. > > > > > Also, even though those unparented views have an applicationState tracker, > > > they seem to return early whenever they get notifications, this seems > > > unfortunate. > > > > That's literally the whole point of Geoff's suggestion (and that's how - > > like I mention above - they aren't doing any work) > > Just because they are returning early does not mean we're not doing any > work. There is certainly a cost memory wise and computation wise to having > many clients registered for notifications that they actually do not care > about. So it sounds to me like you are suggesting that the original patch is a better approach and that Geoff's suggestion that we always keep the notifier around is a bad one? 1525807 12 cdumez 2019-04-09 16:51:21 -0700 (In reply to Brady Eidson from comment #11) > (In reply to Chris Dumez from comment #10) > > (In reply to Brady Eidson from comment #9) > > > (In reply to Chris Dumez from comment #8) > > > > Comment on attachment 367058 [details] > > > > Patch > > > > > > > > View in context: > > > > https://bugs.webkit.org/attachment.cgi?id=367058&action=review > > > > > > > > > Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm:49 > > > > > + _applicationStateTracker = std::make_unique<WebKit::ApplicationStateTracker>(self, @selector(_applicationDidEnterBackground), @selector(_applicationDidFinishSnapshottingAfterEnteringBackground), @selector(_applicationWillEnterForeground)); > > > > > > > > I do not understand why we're making this particular change. It used to be > > > > that only parent views would have an ApplicationStateTracker. Now all views > > > > get one and get notified whenever the app goes to background / foreground. > > > > Aren't we doing a lot of unnecessary work? > > > > > > They are getting notified, but they aren't doing any work. > > > > > > > Also, even though those unparented views have an applicationState tracker, > > > > they seem to return early whenever they get notifications, this seems > > > > unfortunate. > > > > > > That's literally the whole point of Geoff's suggestion (and that's how - > > > like I mention above - they aren't doing any work) > > > > Just because they are returning early does not mean we're not doing any > > work. There is certainly a cost memory wise and computation wise to having > > many clients registered for notifications that they actually do not care > > about. > > So it sounds to me like you are suggesting that the original patch is a > better approach and that Geoff's suggestion that we always keep the notifier > around is a bad one? I definitely liked the original patch better, yes. If Geoff suggested this then I'll let him review. 1525819 13 367087 beidson 2019-04-09 17:14:37 -0700 Created attachment 367087 Patch 1525958 14 beidson 2019-04-10 09:11:12 -0700 (I believe the Geoff r- on the first patch was do to the not-paying-attn-to-background state, which I've resolved here and Chris r+'ed) 1525972 15 367087 commit-queue 2019-04-10 09:32:36 -0700 Comment on attachment 367087 Patch Clearing flags on attachment: 367087 Committed r244113: <https://trac.webkit.org/changeset/244113> 1525973 16 commit-queue 2019-04-10 09:32:38 -0700 All reviewed patches have been landed. Closing bug. 366979 2019-04-08 14:17:51 -0700 2019-04-09 11:57:00 -0700 Patch bug-196705-20190408141750.patch text/plain 4093 beidson U3VidmVyc2lvbiBSZXZpc2lvbjogMjQzOTM2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDYyNTJkMGE4MWNjNTZjM2Ew MjVlZGJiNjNkZGRkMDI5YWI0NDJhZDQuLmU1MjdmNDk3NGUxYzAzNDk3Njc2OTg0NTE2MWYzZDc5 YmJmM2VjYTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTktMDQtMDggIEJyYWR5IEVp ZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgorCisgICAgICAgIEJhY2tncm91bmQgdGFicyBhcmUg bm90IGZ1bGx5IHJlYWN0aXZhdGVkIGFmdGVyIGEgbGluayBpcyBvcGVuZWQgZnJvbSBhbiBleHRl cm5hbCBhcHBsaWNhdGlvbi4KKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzQ5NTMzMjc4PiBhbmQg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE5NjcwNQorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElmIGFuIGFwcCB1bnBhcmVu dHMgYSBXS1dlYlZpZXcgcmlnaHQgYWZ0ZXIgYWN0aXZhdGlvbiBidXQgYmVmb3JlIHRoZSAiYXBw bGljYXRpb25XaWxsRW50ZXJGb3JlZ3JvdW5kIiBub3RpZmljYXRpb24KKyAgICAgICAgaXMgZGlz cGF0Y2hlZCwgdGhlbiB0aGF0IFdLV2ViVmlldyBpcyBpbiBhIGJyb2tlbiBzdGF0ZSB3aXRoIGEg ZnJvemVuIGxheWVyIHRyZWUuCisKKyAgICAgICAgVGhlIEFwcGxpY2F0aW9uU3RhdGVUcmFja2Vy IGxvZ2ljIG5lZWRzIHRvIGJlIGEgbGl0dGxlIHRpZ2h0ZXIuCisKKyAgICAgICAgQnkga2VlcGlu ZyB0cmFjayBvZiB3aGVuIGEgdmlldyB0aGlua3MgdGhlIGFwcCBpcyBiYWNrZ3JvdW5kZWQsIHdl IGNhbiBtYWtlIHN1cmUgaXQga25vd3MgdGhlIGFwcCBpcyBmb3JlZ3JvdW5kZWQKKyAgICAgICAg d2hlbiB0aGUgdmlldyBpcyByZXBhcmVudGVkLgorCisgICAgICAgICogVUlQcm9jZXNzL2lvcy9X S0FwcGxpY2F0aW9uU3RhdGVUcmFja2luZ1ZpZXcubW06CisgICAgICAgICgtW1dLQXBwbGljYXRp b25TdGF0ZVRyYWNraW5nVmlldyBpbml0V2l0aEZyYW1lOndlYlZpZXc6XSk6CisgICAgICAgICgt W1dLQXBwbGljYXRpb25TdGF0ZVRyYWNraW5nVmlldyBkaWRNb3ZlVG9XaW5kb3ddKToKKyAgICAg ICAgKC1bV0tBcHBsaWNhdGlvblN0YXRlVHJhY2tpbmdWaWV3IF9hcHBsaWNhdGlvbkRpZEVudGVy QmFja2dyb3VuZF0pOgorICAgICAgICAoLVtXS0FwcGxpY2F0aW9uU3RhdGVUcmFja2luZ1ZpZXcg X2FwcGxpY2F0aW9uV2lsbEVudGVyRm9yZWdyb3VuZF0pOgorCiAyMDE5LTA0LTA1ICBDb21taXQg UXVldWUgIDxjb21taXQtcXVldWVAd2Via2l0Lm9yZz4KIAogICAgICAgICBVbnJldmlld2VkLCBy b2xsaW5nIG91dCByMjQzODMzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv aW9zL1dLQXBwbGljYXRpb25TdGF0ZVRyYWNraW5nVmlldy5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL2lvcy9XS0FwcGxpY2F0aW9uU3RhdGVUcmFja2luZ1ZpZXcubW0KaW5kZXggOGMxYjg2 OTZkYjRhOTU0MmE0YmU3ZjU2YTBiY2VhODg3ZmFmNjI5MC4uNGMxODlhODM1YzczZTFlM2JiNWZk MDE5OGVlMDQzOTcyNDEyZWM4NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv aW9zL1dLQXBwbGljYXRpb25TdGF0ZVRyYWNraW5nVmlldy5tbQorKysgYi9Tb3VyY2UvV2ViS2l0 L1VJUHJvY2Vzcy9pb3MvV0tBcHBsaWNhdGlvblN0YXRlVHJhY2tpbmdWaWV3Lm1tCkBAIC0zNCw5 ICszNCwxNSBAQAogI2ltcG9ydCA8d3RmL1JldGFpblB0ci5oPgogI2ltcG9ydCA8d3RmL1dlYWtP YmpDUHRyLmg+CiAKK2VudW0gY2xhc3MgTGFzdFRyYWNrZWRBcHBsaWNhdGlvblN0YXRlIHsKKyAg ICBGb3JlZ3JvdW5kLAorICAgIEJhY2tncm91bmQsCit9OworCiBAaW1wbGVtZW50YXRpb24gV0tB cHBsaWNhdGlvblN0YXRlVHJhY2tpbmdWaWV3IHsKICAgICBXZWFrT2JqQ1B0cjxXS1dlYlZpZXc+ IF93ZWJWaWV3VG9UcmFjazsKICAgICBzdGQ6OnVuaXF1ZV9wdHI8V2ViS2l0OjpBcHBsaWNhdGlv blN0YXRlVHJhY2tlcj4gX2FwcGxpY2F0aW9uU3RhdGVUcmFja2VyOworICAgIExhc3RUcmFja2Vk QXBwbGljYXRpb25TdGF0ZSBfbGFzdFRyYWNrZWRBcHBsaWNhdGlvblN0YXRlOwogfQogCiAtIChp bnN0YW5jZXR5cGUpaW5pdFdpdGhGcmFtZTooQ0dSZWN0KWZyYW1lIHdlYlZpZXc6KFdLV2ViVmll dyAqKXdlYlZpZXcKQEAgLTQ1LDYgKzUxLDcgQEAgLSAoaW5zdGFuY2V0eXBlKWluaXRXaXRoRnJh bWU6KENHUmVjdClmcmFtZSB3ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJWaWV3CiAgICAgICAgIHJl dHVybiBuaWw7CiAKICAgICBfd2ViVmlld1RvVHJhY2sgPSB3ZWJWaWV3OworICAgIF9sYXN0VHJh Y2tlZEFwcGxpY2F0aW9uU3RhdGUgPSBMYXN0VHJhY2tlZEFwcGxpY2F0aW9uU3RhdGU6OkZvcmVn cm91bmQ7CiAgICAgcmV0dXJuIHNlbGY7CiB9CiAKQEAgLTY0LDYgKzcxLDEyIEBAIC0gKHZvaWQp ZGlkTW92ZVRvV2luZG93CiAKICAgICBBU1NFUlQoIV9hcHBsaWNhdGlvblN0YXRlVHJhY2tlcik7 CiAgICAgX2FwcGxpY2F0aW9uU3RhdGVUcmFja2VyID0gc3RkOjptYWtlX3VuaXF1ZTxXZWJLaXQ6 OkFwcGxpY2F0aW9uU3RhdGVUcmFja2VyPihzZWxmLCBAc2VsZWN0b3IoX2FwcGxpY2F0aW9uRGlk RW50ZXJCYWNrZ3JvdW5kKSwgQHNlbGVjdG9yKF9hcHBsaWNhdGlvbkRpZEZpbmlzaFNuYXBzaG90 dGluZ0FmdGVyRW50ZXJpbmdCYWNrZ3JvdW5kKSwgQHNlbGVjdG9yKF9hcHBsaWNhdGlvbldpbGxF bnRlckZvcmVncm91bmQpKTsKKyAgICAKKyAgICAvLyBUaGUgYXNzb2NpYXRlZCBXS1dlYlZpZXcg bWlnaHQgdGhpbmsgdGhlIGFwcGxpY2F0aW9uIGlzIGJhY2tncm91bmRlZCwgaGF2aW5nIG1pc3Nl ZCB0aGUgIl9hcHBsaWNhdGlvbldpbGxFbnRlckZvcmVncm91bmQiCisgICAgLy8gbm90aWZpY2F0 aW9uIGJlY2F1c2UgaXQgd2Fzbid0IHBhcmVudGVkIGluIGEgd2luZG93IGFuZCB0aGVyZWZvcmUg d2Fzbid0IGxpc3RlbmluZy4KKyAgICAvLyBJbiB0aGlzIGNhc2Ugd2Ugc2hvdWxkIHJlcGxheSB0 aGUgIl9hcHBsaWNhdGlvbldpbGxFbnRlckZvcmVncm91bmQiIG5vdGlmaWNhdGlvbi4KKyAgICBp ZiAoX2xhc3RUcmFja2VkQXBwbGljYXRpb25TdGF0ZSA9PSBMYXN0VHJhY2tlZEFwcGxpY2F0aW9u U3RhdGU6OkJhY2tncm91bmQpCisgICAgICAgIFtzZWxmIF9hcHBsaWNhdGlvbldpbGxFbnRlckZv cmVncm91bmRdOwogfQogCiAtICh2b2lkKV9hcHBsaWNhdGlvbkRpZEVudGVyQmFja2dyb3VuZApA QCAtNzIsNiArODUsOCBAQCAtICh2b2lkKV9hcHBsaWNhdGlvbkRpZEVudGVyQmFja2dyb3VuZAog ICAgIGlmICghcGFnZSkKICAgICAgICAgcmV0dXJuOwogCisgICAgX2xhc3RUcmFja2VkQXBwbGlj YXRpb25TdGF0ZSA9IExhc3RUcmFja2VkQXBwbGljYXRpb25TdGF0ZTo6QmFja2dyb3VuZDsKKyAg ICAKICAgICBwYWdlLT5hcHBsaWNhdGlvbkRpZEVudGVyQmFja2dyb3VuZCgpOwogICAgIHBhZ2Ut PmFjdGl2aXR5U3RhdGVEaWRDaGFuZ2UoV2ViQ29yZTo6QWN0aXZpdHlTdGF0ZTo6YWxsRmxhZ3Mo KSAtIFdlYkNvcmU6OkFjdGl2aXR5U3RhdGU6OklzSW5XaW5kb3cpOwogfQpAQCAtODgsNiArMTAz LDggQEAgLSAodm9pZClfYXBwbGljYXRpb25XaWxsRW50ZXJGb3JlZ3JvdW5kCiAgICAgaWYgKCFw YWdlKQogICAgICAgICByZXR1cm47CiAKKyAgICBfbGFzdFRyYWNrZWRBcHBsaWNhdGlvblN0YXRl ID0gTGFzdFRyYWNrZWRBcHBsaWNhdGlvblN0YXRlOjpGb3JlZ3JvdW5kOworCiAgICAgcGFnZS0+ YXBwbGljYXRpb25XaWxsRW50ZXJGb3JlZ3JvdW5kKCk7CiAgICAgcGFnZS0+YWN0aXZpdHlTdGF0 ZURpZENoYW5nZShXZWJDb3JlOjpBY3Rpdml0eVN0YXRlOjphbGxGbGFncygpIC0gV2ViQ29yZTo6 QWN0aXZpdHlTdGF0ZTo6SXNJbldpbmRvdywgdHJ1ZSwgV2ViS2l0OjpXZWJQYWdlUHJveHk6OkFj dGl2aXR5U3RhdGVDaGFuZ2VEaXNwYXRjaE1vZGU6OkltbWVkaWF0ZSk7CiB9Cg== 367058 2019-04-09 11:57:01 -0700 2019-04-09 17:14:36 -0700 Patch bug-196705-20190409115700.patch text/plain 5875 beidson U3VidmVyc2lvbiBSZXZpc2lvbjogMjQ0MDgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDgzZmViOGQ3M2RlYWUxYjJl YTNlZjdlNTY3ZTUxN2I2NTUyNTk4OGEuLjNjN2QxY2M0NDU3MTg5YTAxODg2ZmM4MWJkMTE4Nzdl MmI4NjRjYmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTktMDQtMDkgIEJyYWR5IEVp ZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgorCisgICAgICAgIEJhY2tncm91bmQgdGFicyBhcmUg bm90IGZ1bGx5IHJlYWN0aXZhdGVkIGFmdGVyIGEgbGluayBpcyBvcGVuZWQgZnJvbSBhbiBleHRl cm5hbCBhcHBsaWNhdGlvbi4KKyAgICAgICAgcmRhcjovL3Byb2JsZW0vNDk1MzMyNzg+IGFuZCBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk2NzA1CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSWYgYW4gYXBwIHVucGFyZW50 cyBhIFdLV2ViVmlldyByaWdodCBhZnRlciBhY3RpdmF0aW9uIGJ1dCBiZWZvcmUgdGhlICJhcHBs aWNhdGlvbldpbGxFbnRlckZvcmVncm91bmQiIG5vdGlmaWNhdGlvbgorICAgICAgICBpcyBkaXNw YXRjaGVkLCB0aGVuIHRoYXQgV0tXZWJWaWV3IGlzIGluIGEgYnJva2VuIHN0YXRlIHdpdGggYSBm cm96ZW4gbGF5ZXIgdHJlZS4KKworICAgICAgICBUaGUgV0tBcHBsaWNhdGlvblN0YXRlVHJhY2tp bmdWaWV3IGxvZ2ljIG5lZWRzIHRvIGJlIGEgbGl0dGxlIHRpZ2h0ZXIuCisKKyAgICAgICAgQnkg a2VlcGluZyB0cmFjayBvZiB3aGVuIGEgdmlldyB0aGlua3MgdGhlIGFwcCBpcyBiYWNrZ3JvdW5k ZWQsIHdlIGNhbiBtYWtlIHN1cmUgaXQga25vd3MgdGhlIGFwcCBpcyBmb3JlZ3JvdW5kZWQKKyAg ICAgICAgd2hlbiB0aGUgdmlldyBpcyByZXBhcmVudGVkLgorCisgICAgICAgICogVUlQcm9jZXNz L2lvcy9XS0FwcGxpY2F0aW9uU3RhdGVUcmFja2luZ1ZpZXcubW06CisgICAgICAgICgtW1dLQXBw bGljYXRpb25TdGF0ZVRyYWNraW5nVmlldyBpbml0V2l0aEZyYW1lOndlYlZpZXc6XSk6IEFsd2F5 cyBjcmVhdGUgdGhlIEFwcGxpY2F0aW9uU3RhdGVUcmFja2VyIGhlcmUuCisgICAgICAgICAgV0tX ZWJWaWV3cyBub3cgYWx3YXlzIGhhdmUgb25lLgorICAgICAgICAoLVtXS0FwcGxpY2F0aW9uU3Rh dGVUcmFja2luZ1ZpZXcgd2lsbE1vdmVUb1dpbmRvdzpdKTogV2hlbiByZXBhcmVudGluZywgaWYg dGhpcyB2aWV3J3MgY29uY2VwdCBvZiBiYWNrZ3JvdW5kL2ZvcmVncm91bmQKKyAgICAgICAgICBp cyBvdXQgb2YgZGF0ZSwgdGhlbiByZXBsYXkgdGhlIGFwcHJvcHJpYXRlIG5vdGlmaWNhdGlvbi4K KyAgICAgICAgKC1bV0tBcHBsaWNhdGlvblN0YXRlVHJhY2tpbmdWaWV3IF9hcHBsaWNhdGlvbkRp ZEVudGVyQmFja2dyb3VuZF0pOiBEb24ndCByZXNwb25kIHRvIHRoaXMgbm90aWZpY2F0aW9uIGlm IG5vdCBpbiBhIHdpbmRvdy4KKyAgICAgICAgKC1bV0tBcHBsaWNhdGlvblN0YXRlVHJhY2tpbmdW aWV3IF9kb0FwcGxpY2F0aW9uRGlkRW50ZXJCYWNrZ3JvdW5kXSk6CisgICAgICAgICgtW1dLQXBw bGljYXRpb25TdGF0ZVRyYWNraW5nVmlldyBfYXBwbGljYXRpb25EaWRGaW5pc2hTbmFwc2hvdHRp bmdBZnRlckVudGVyaW5nQmFja2dyb3VuZF0pOgorICAgICAgICAoLVtXS0FwcGxpY2F0aW9uU3Rh dGVUcmFja2luZ1ZpZXcgX2FwcGxpY2F0aW9uV2lsbEVudGVyRm9yZWdyb3VuZF0pOiBEb24ndCBy ZXNwb25kIHRvIHRoaXMgbm90aWZpY2F0aW9uIGlmIG5vdCBpbiBhIHdpbmRvdy4KKyAgICAgICAg KC1bV0tBcHBsaWNhdGlvblN0YXRlVHJhY2tpbmdWaWV3IF9kb0FwcGxpY2F0aW9uV2lsbEVudGVy Rm9yZWdyb3VuZF0pOgorICAgICAgICAoLVtXS0FwcGxpY2F0aW9uU3RhdGVUcmFja2luZ1ZpZXcg aXNCYWNrZ3JvdW5kXSk6CisgICAgICAgICgtW1dLQXBwbGljYXRpb25TdGF0ZVRyYWNraW5nVmll dyBkaWRNb3ZlVG9XaW5kb3ddKTogRGVsZXRlZCAtIFdlIG5vIGxvbmdlciBuZWVkIHRvIHJlY3Jl YXRlIHRoZSBBcHBsaWNhdGlvblN0YXRlVHJhY2tlcgorICAgICAgICAgIHNpbmNlIHdlIG5ldmVy IGRlc3Ryb3kgaXQuCisKIDIwMTktMDQtMDkgIFNpaHVpIExpdSAgPHNpaHVpX2xpdUBhcHBsZS5j b20+CiAKICAgICAgICAgUmVtb3ZlIHVubmVjZXNzYXJ5IG5ldHdvcmsgcHJvY2VzcyBhc3NlcnRp b24gZm9yIElEQiBjbG9zZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvaW9z L1dLQXBwbGljYXRpb25TdGF0ZVRyYWNraW5nVmlldy5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL2lvcy9XS0FwcGxpY2F0aW9uU3RhdGVUcmFja2luZ1ZpZXcubW0KaW5kZXggOGMxYjg2OTZk YjRhOTU0MmE0YmU3ZjU2YTBiY2VhODg3ZmFmNjI5MC4uNTI1MWZkM2U5MWFkN2M1MGU0NjY5NGUw Y2Q4ZjU1OTBhZWQ5MzYyNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvaW9z L1dLQXBwbGljYXRpb25TdGF0ZVRyYWNraW5nVmlldy5tbQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9pb3MvV0tBcHBsaWNhdGlvblN0YXRlVHJhY2tpbmdWaWV3Lm1tCkBAIC0zNyw2ICsz Nyw3IEBACiBAaW1wbGVtZW50YXRpb24gV0tBcHBsaWNhdGlvblN0YXRlVHJhY2tpbmdWaWV3IHsK ICAgICBXZWFrT2JqQ1B0cjxXS1dlYlZpZXc+IF93ZWJWaWV3VG9UcmFjazsKICAgICBzdGQ6OnVu aXF1ZV9wdHI8V2ViS2l0OjpBcHBsaWNhdGlvblN0YXRlVHJhY2tlcj4gX2FwcGxpY2F0aW9uU3Rh dGVUcmFja2VyOworICAgIEJPT0wgX2xhc3RIYW5kbGVkU3RhdGVXYXNCYWNrZ3JvdW5kOwogfQog CiAtIChpbnN0YW5jZXR5cGUpaW5pdFdpdGhGcmFtZTooQ0dSZWN0KWZyYW1lIHdlYlZpZXc6KFdL V2ViVmlldyAqKXdlYlZpZXcKQEAgLTQ1LDU2ICs0Niw3NCBAQCAtIChpbnN0YW5jZXR5cGUpaW5p dFdpdGhGcmFtZTooQ0dSZWN0KWZyYW1lIHdlYlZpZXc6KFdLV2ViVmlldyAqKXdlYlZpZXcKICAg ICAgICAgcmV0dXJuIG5pbDsKIAogICAgIF93ZWJWaWV3VG9UcmFjayA9IHdlYlZpZXc7CisgICAg X2FwcGxpY2F0aW9uU3RhdGVUcmFja2VyID0gc3RkOjptYWtlX3VuaXF1ZTxXZWJLaXQ6OkFwcGxp Y2F0aW9uU3RhdGVUcmFja2VyPihzZWxmLCBAc2VsZWN0b3IoX2FwcGxpY2F0aW9uRGlkRW50ZXJC YWNrZ3JvdW5kKSwgQHNlbGVjdG9yKF9hcHBsaWNhdGlvbkRpZEZpbmlzaFNuYXBzaG90dGluZ0Fm dGVyRW50ZXJpbmdCYWNrZ3JvdW5kKSwgQHNlbGVjdG9yKF9hcHBsaWNhdGlvbldpbGxFbnRlckZv cmVncm91bmQpKTsKKyAgICBfbGFzdEhhbmRsZWRTdGF0ZVdhc0JhY2tncm91bmQgPSBbc2VsZiBp c0JhY2tncm91bmRdOworCiAgICAgcmV0dXJuIHNlbGY7CiB9CiAKIC0gKHZvaWQpd2lsbE1vdmVU b1dpbmRvdzooVUlXaW5kb3cgKiluZXdXaW5kb3cKIHsKLSAgICBpZiAoIXNlbGYuX2NvbnRlbnRW aWV3LndpbmRvdyB8fCBuZXdXaW5kb3cpCisgICAgaWYgKHNlbGYuX2NvbnRlbnRWaWV3LndpbmRv dykKICAgICAgICAgcmV0dXJuOwotCi0gICAgQVNTRVJUKF9hcHBsaWNhdGlvblN0YXRlVHJhY2tl cik7Ci0gICAgX2FwcGxpY2F0aW9uU3RhdGVUcmFja2VyID0gbnVsbHB0cjsKKyAgICAKKyAgICAv LyBXZSBzaG91bGQgbmV2ZXIgYmUgdG9sZCB3ZSdyZSBtb3ZpbmcgZnJvbSBhIG5pbCB3aW5kb3cg dG8gYSBkaWZmZXJlbnQgbmlsIHdpbmRvdy4KKyAgICBBU1NFUlQobmV3V2luZG93KTsKKyAgICAK KyAgICBpZiAoX2xhc3RIYW5kbGVkU3RhdGVXYXNCYWNrZ3JvdW5kICYmICFbc2VsZiBpc0JhY2tn cm91bmRdKQorICAgICAgICBbc2VsZiBfZG9BcHBsaWNhdGlvbldpbGxFbnRlckZvcmVncm91bmRd OworICAgIGVsc2UgaWYgKCFfbGFzdEhhbmRsZWRTdGF0ZVdhc0JhY2tncm91bmQgJiYgW3NlbGYg aXNCYWNrZ3JvdW5kXSkKKyAgICAgICAgW3NlbGYgX2RvQXBwbGljYXRpb25EaWRFbnRlckJhY2tn cm91bmRdOwogfQogCi0tICh2b2lkKWRpZE1vdmVUb1dpbmRvdworLSAodm9pZClfYXBwbGljYXRp b25EaWRFbnRlckJhY2tncm91bmQKIHsKICAgICBpZiAoIXNlbGYuX2NvbnRlbnRWaWV3LndpbmRv dykKICAgICAgICAgcmV0dXJuOwotCi0gICAgQVNTRVJUKCFfYXBwbGljYXRpb25TdGF0ZVRyYWNr ZXIpOwotICAgIF9hcHBsaWNhdGlvblN0YXRlVHJhY2tlciA9IHN0ZDo6bWFrZV91bmlxdWU8V2Vi S2l0OjpBcHBsaWNhdGlvblN0YXRlVHJhY2tlcj4oc2VsZiwgQHNlbGVjdG9yKF9hcHBsaWNhdGlv bkRpZEVudGVyQmFja2dyb3VuZCksIEBzZWxlY3RvcihfYXBwbGljYXRpb25EaWRGaW5pc2hTbmFw c2hvdHRpbmdBZnRlckVudGVyaW5nQmFja2dyb3VuZCksIEBzZWxlY3RvcihfYXBwbGljYXRpb25X aWxsRW50ZXJGb3JlZ3JvdW5kKSk7CisgICAgW3NlbGYgX2RvQXBwbGljYXRpb25EaWRFbnRlckJh Y2tncm91bmRdOwogfQogCi0tICh2b2lkKV9hcHBsaWNhdGlvbkRpZEVudGVyQmFja2dyb3VuZAor LSAodm9pZClfZG9BcHBsaWNhdGlvbkRpZEVudGVyQmFja2dyb3VuZAogewogICAgIGF1dG8gcGFn ZSA9IFtfd2ViVmlld1RvVHJhY2sgX3BhZ2VdOwogICAgIGlmICghcGFnZSkKICAgICAgICAgcmV0 dXJuOwogCisgICAgX2xhc3RIYW5kbGVkU3RhdGVXYXNCYWNrZ3JvdW5kID0gWUVTOwogICAgIHBh Z2UtPmFwcGxpY2F0aW9uRGlkRW50ZXJCYWNrZ3JvdW5kKCk7CiAgICAgcGFnZS0+YWN0aXZpdHlT dGF0ZURpZENoYW5nZShXZWJDb3JlOjpBY3Rpdml0eVN0YXRlOjphbGxGbGFncygpIC0gV2ViQ29y ZTo6QWN0aXZpdHlTdGF0ZTo6SXNJbldpbmRvdyk7CiB9CiAKIC0gKHZvaWQpX2FwcGxpY2F0aW9u RGlkRmluaXNoU25hcHNob3R0aW5nQWZ0ZXJFbnRlcmluZ0JhY2tncm91bmQKIHsKKyAgICBpZiAo IXNlbGYuX2NvbnRlbnRWaWV3LndpbmRvdykKKyAgICAgICAgcmV0dXJuOworCiAgICAgaWYgKGF1 dG8gcGFnZSA9IFtfd2ViVmlld1RvVHJhY2sgX3BhZ2VdKQogICAgICAgICBwYWdlLT5hcHBsaWNh dGlvbkRpZEZpbmlzaFNuYXBzaG90dGluZ0FmdGVyRW50ZXJpbmdCYWNrZ3JvdW5kKCk7CiB9CiAK IC0gKHZvaWQpX2FwcGxpY2F0aW9uV2lsbEVudGVyRm9yZWdyb3VuZAoreworICAgIGlmICghc2Vs Zi5fY29udGVudFZpZXcud2luZG93KQorICAgICAgICByZXR1cm47CisgICAgW3NlbGYgX2RvQXBw bGljYXRpb25XaWxsRW50ZXJGb3JlZ3JvdW5kXTsKK30KKworLSAodm9pZClfZG9BcHBsaWNhdGlv bldpbGxFbnRlckZvcmVncm91bmQKIHsKICAgICBhdXRvIHBhZ2UgPSBbX3dlYlZpZXdUb1RyYWNr IF9wYWdlXTsKICAgICBpZiAoIXBhZ2UpCiAgICAgICAgIHJldHVybjsKIAorICAgIF9sYXN0SGFu ZGxlZFN0YXRlV2FzQmFja2dyb3VuZCA9IE5POwogICAgIHBhZ2UtPmFwcGxpY2F0aW9uV2lsbEVu dGVyRm9yZWdyb3VuZCgpOwogICAgIHBhZ2UtPmFjdGl2aXR5U3RhdGVEaWRDaGFuZ2UoV2ViQ29y ZTo6QWN0aXZpdHlTdGF0ZTo6YWxsRmxhZ3MoKSAtIFdlYkNvcmU6OkFjdGl2aXR5U3RhdGU6Oklz SW5XaW5kb3csIHRydWUsIFdlYktpdDo6V2ViUGFnZVByb3h5OjpBY3Rpdml0eVN0YXRlQ2hhbmdl RGlzcGF0Y2hNb2RlOjpJbW1lZGlhdGUpOwogfQogCiAtIChCT09MKWlzQmFja2dyb3VuZAogewot ICAgIHJldHVybiBfYXBwbGljYXRpb25TdGF0ZVRyYWNrZXIgPyBfYXBwbGljYXRpb25TdGF0ZVRy YWNrZXItPmlzSW5CYWNrZ3JvdW5kKCkgOiBZRVM7CisgICAgcmV0dXJuIF9hcHBsaWNhdGlvblN0 YXRlVHJhY2tlci0+aXNJbkJhY2tncm91bmQoKTsKIH0KIAogLSAoVUlWaWV3ICopX2NvbnRlbnRW aWV3Cg== 367087 2019-04-09 17:14:37 -0700 2019-04-10 09:32:36 -0700 Patch bug-196705-20190409171437.patch text/plain 3830 beidson U3VidmVyc2lvbiBSZXZpc2lvbjogMjQ0MDgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDgzZmViOGQ3M2RlYWUxYjJl YTNlZjdlNTY3ZTUxN2I2NTUyNTk4OGEuLjMzODhhYWU1ZWNlZjQ1MmU3MWMzMTE5Zjc2ZjM2N2Iw OTI2OTAwYWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTktMDQtMDkgIEJyYWR5IEVp ZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgorCisgICAgICAgIEJhY2tncm91bmQgdGFicyBhcmUg bm90IGZ1bGx5IHJlYWN0aXZhdGVkIGFmdGVyIGEgbGluayBpcyBvcGVuZWQgZnJvbSBhbiBleHRl cm5hbCBhcHBsaWNhdGlvbi4KKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzQ5NTMzMjc4PiBhbmQg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE5NjcwNQorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElmIGFuIGFwcCB1bnBhcmVu dHMgYSBXS1dlYlZpZXcgcmlnaHQgYWZ0ZXIgYWN0aXZhdGlvbiBidXQgYmVmb3JlIHRoZSAiYXBw bGljYXRpb25XaWxsRW50ZXJGb3JlZ3JvdW5kIiBub3RpZmljYXRpb24KKyAgICAgICAgaXMgZGlz cGF0Y2hlZCwgdGhlbiB0aGF0IFdLV2ViVmlldyBpcyBpbiBhIGJyb2tlbiBzdGF0ZSB3aXRoIGEg ZnJvemVuIGxheWVyIHRyZWUuCisKKyAgICAgICAgVGhlIFdLQXBwbGljYXRpb25TdGF0ZVRyYWNr aW5nVmlldyBsb2dpYyBuZWVkcyB0byBiZSBhIGxpdHRsZSBtb3JlIHJlc2lsaWVudC4KKworICAg ICAgICAqIFVJUHJvY2Vzcy9pb3MvV0tBcHBsaWNhdGlvblN0YXRlVHJhY2tpbmdWaWV3Lm1tOgor ICAgICAgICAoLVtXS0FwcGxpY2F0aW9uU3RhdGVUcmFja2luZ1ZpZXcgd2lsbE1vdmVUb1dpbmRv dzpdKTogV2hlbiBjbGVhcmluZyB0aGUgd2luZG93LCByZW1lbWJlciB0aGUgY3VycmVudCBiYWNr Z3JvdW5kIHN0YXRlLgorICAgICAgICAoLVtXS0FwcGxpY2F0aW9uU3RhdGVUcmFja2luZ1ZpZXcg ZGlkTW92ZVRvV2luZG93XSk6IElmIG91ciBsYXN0IG9ic2VydmVkIGJhY2tncm91bmQgc3RhdGUg ZG9lc24ndCBtYXRjaCB0aGUgY3VycmVudAorICAgICAgICAgIGJhY2tncm91bmQgc3RhdGUgdGhl biBmYWtlIHRoZSByZWxldmFudCBub3RpZmljYXRpb24uCisgICAgICAgICgtW1dLQXBwbGljYXRp b25TdGF0ZVRyYWNraW5nVmlldyBfYXBwbGljYXRpb25EaWRFbnRlckJhY2tncm91bmRdKTogUmVt ZW1iZXIgdGhhdCB3ZSd2ZSBvYnNlcnZlZCBhIGJhY2tncm91bmRpbmcuCisgICAgICAgICgtW1dL QXBwbGljYXRpb25TdGF0ZVRyYWNraW5nVmlldyBfYXBwbGljYXRpb25XaWxsRW50ZXJGb3JlZ3Jv dW5kXSk6IFJlbWVtYmVyIHRoYXQgd2UndmUgb2JzZXJ2ZWQgYSBmb3JlZ3JvdW5kaW5nLgorCiAy MDE5LTA0LTA5ICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgogCiAgICAgICAgIFJl bW92ZSB1bm5lY2Vzc2FyeSBuZXR3b3JrIHByb2Nlc3MgYXNzZXJ0aW9uIGZvciBJREIgY2xvc2UK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2lvcy9XS0FwcGxpY2F0aW9uU3Rh dGVUcmFja2luZ1ZpZXcubW0gYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9pb3MvV0tBcHBsaWNh dGlvblN0YXRlVHJhY2tpbmdWaWV3Lm1tCmluZGV4IDhjMWI4Njk2ZGI0YTk1NDJhNGJlN2Y1NmEw YmNlYTg4N2ZhZjYyOTAuLjEyYTJiM2FkNTZlZTYyYTQwYzhhMTk1MDQ5MThiODEyMTczMzE0ZDUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2lvcy9XS0FwcGxpY2F0aW9uU3Rh dGVUcmFja2luZ1ZpZXcubW0KKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvaW9zL1dLQXBw bGljYXRpb25TdGF0ZVRyYWNraW5nVmlldy5tbQpAQCAtMzcsNiArMzcsNyBAQAogQGltcGxlbWVu dGF0aW9uIFdLQXBwbGljYXRpb25TdGF0ZVRyYWNraW5nVmlldyB7CiAgICAgV2Vha09iakNQdHI8 V0tXZWJWaWV3PiBfd2ViVmlld1RvVHJhY2s7CiAgICAgc3RkOjp1bmlxdWVfcHRyPFdlYktpdDo6 QXBwbGljYXRpb25TdGF0ZVRyYWNrZXI+IF9hcHBsaWNhdGlvblN0YXRlVHJhY2tlcjsKKyAgICBC T09MIF9sYXN0T2JzZXJ2ZWRTdGF0ZVdhc0JhY2tncm91bmQ7CiB9CiAKIC0gKGluc3RhbmNldHlw ZSlpbml0V2l0aEZyYW1lOihDR1JlY3QpZnJhbWUgd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmll dwpAQCAtNTMsNiArNTQsOCBAQCAtICh2b2lkKXdpbGxNb3ZlVG9XaW5kb3c6KFVJV2luZG93ICop bmV3V2luZG93CiAgICAgaWYgKCFzZWxmLl9jb250ZW50Vmlldy53aW5kb3cgfHwgbmV3V2luZG93 KQogICAgICAgICByZXR1cm47CiAKKyAgICBfbGFzdE9ic2VydmVkU3RhdGVXYXNCYWNrZ3JvdW5k ID0gW3NlbGYgaXNCYWNrZ3JvdW5kXTsKKwogICAgIEFTU0VSVChfYXBwbGljYXRpb25TdGF0ZVRy YWNrZXIpOwogICAgIF9hcHBsaWNhdGlvblN0YXRlVHJhY2tlciA9IG51bGxwdHI7CiB9CkBAIC02 NCw2ICs2NywxMSBAQCAtICh2b2lkKWRpZE1vdmVUb1dpbmRvdwogCiAgICAgQVNTRVJUKCFfYXBw bGljYXRpb25TdGF0ZVRyYWNrZXIpOwogICAgIF9hcHBsaWNhdGlvblN0YXRlVHJhY2tlciA9IHN0 ZDo6bWFrZV91bmlxdWU8V2ViS2l0OjpBcHBsaWNhdGlvblN0YXRlVHJhY2tlcj4oc2VsZiwgQHNl bGVjdG9yKF9hcHBsaWNhdGlvbkRpZEVudGVyQmFja2dyb3VuZCksIEBzZWxlY3RvcihfYXBwbGlj YXRpb25EaWRGaW5pc2hTbmFwc2hvdHRpbmdBZnRlckVudGVyaW5nQmFja2dyb3VuZCksIEBzZWxl Y3RvcihfYXBwbGljYXRpb25XaWxsRW50ZXJGb3JlZ3JvdW5kKSk7CisgICAgCisgICAgaWYgKF9s YXN0T2JzZXJ2ZWRTdGF0ZVdhc0JhY2tncm91bmQgJiYgIVtzZWxmIGlzQmFja2dyb3VuZF0pCisg ICAgICAgIFtzZWxmIF9hcHBsaWNhdGlvbldpbGxFbnRlckZvcmVncm91bmRdOworICAgIGVsc2Ug aWYgKCFfbGFzdE9ic2VydmVkU3RhdGVXYXNCYWNrZ3JvdW5kICYmIFtzZWxmIGlzQmFja2dyb3Vu ZF0pCisgICAgICAgIFtzZWxmIF9hcHBsaWNhdGlvbkRpZEVudGVyQmFja2dyb3VuZF07CiB9CiAK IC0gKHZvaWQpX2FwcGxpY2F0aW9uRGlkRW50ZXJCYWNrZ3JvdW5kCkBAIC03Miw2ICs4MCw3IEBA IC0gKHZvaWQpX2FwcGxpY2F0aW9uRGlkRW50ZXJCYWNrZ3JvdW5kCiAgICAgaWYgKCFwYWdlKQog ICAgICAgICByZXR1cm47CiAKKyAgICBfbGFzdE9ic2VydmVkU3RhdGVXYXNCYWNrZ3JvdW5kID0g WUVTOwogICAgIHBhZ2UtPmFwcGxpY2F0aW9uRGlkRW50ZXJCYWNrZ3JvdW5kKCk7CiAgICAgcGFn ZS0+YWN0aXZpdHlTdGF0ZURpZENoYW5nZShXZWJDb3JlOjpBY3Rpdml0eVN0YXRlOjphbGxGbGFn cygpIC0gV2ViQ29yZTo6QWN0aXZpdHlTdGF0ZTo6SXNJbldpbmRvdyk7CiB9CkBAIC04OCw2ICs5 Nyw3IEBAIC0gKHZvaWQpX2FwcGxpY2F0aW9uV2lsbEVudGVyRm9yZWdyb3VuZAogICAgIGlmICgh cGFnZSkKICAgICAgICAgcmV0dXJuOwogCisgICAgX2xhc3RPYnNlcnZlZFN0YXRlV2FzQmFja2dy b3VuZCA9IE5POwogICAgIHBhZ2UtPmFwcGxpY2F0aW9uV2lsbEVudGVyRm9yZWdyb3VuZCgpOwog ICAgIHBhZ2UtPmFjdGl2aXR5U3RhdGVEaWRDaGFuZ2UoV2ViQ29yZTo6QWN0aXZpdHlTdGF0ZTo6 YWxsRmxhZ3MoKSAtIFdlYkNvcmU6OkFjdGl2aXR5U3RhdGU6OklzSW5XaW5kb3csIHRydWUsIFdl YktpdDo6V2ViUGFnZVByb3h5OjpBY3Rpdml0eVN0YXRlQ2hhbmdlRGlzcGF0Y2hNb2RlOjpJbW1l ZGlhdGUpOwogfQo=