230758 2021-09-24 10:47:48 -0700 Web Inspector: WebInspectorExtensionTabContentView should not reload its iframe when detached 2021-10-07 13:00:31 -0700 1 1 1 Unclassified WebKit Web Inspector WebKit Nightly Build All All RESOLVED FIXED InRadar P2 Normal --- 1 bburg bburg bburg ews-watchlist hi inspector-bugzilla-changes pangle timothy webkit-bug-importer oldest_to_newest 1796948 0 bburg 2021-09-24 10:47:48 -0700 <rdar://74714861> 1798072 1 bburg 2021-09-28 15:23:48 -0700 I've written an API test that demonstrates the issue :D 1799048 2 439785 bburg 2021-09-30 15:35:00 -0700 Created attachment 439785 Patch v1.0 1799092 3 439785 pangle 2021-09-30 16:48:16 -0700 Comment on attachment 439785 Patch v1.0 View in context: https://bugs.webkit.org/attachment.cgi?id=439785&action=review > Source/WebInspectorUI/ChangeLog:25 > + (WI.ContentView.prototype.get shouldDetachWhenHidden): Add new static getter, default is `true`. If this is supposed to be static, it should probably be in a separate section of the class from the overridable instance variables? I left some comments below before I looped back to this one, but I also left a comment on ContentViewContainer.js:426 making the argument that this shouldn't be treated as static, even if currently no implementation dynamically determines this. > Source/WebInspectorUI/UserInterface/Views/ContentView.js:380 > + // Returns false if the content view should *not* be detached from the DOM when hidden. NIT: This comment could probably be replaced with a slightly more descriptive name instead, e.g. `shouldRemoveFromDOMWhenHidden` NIT: Should have a comment `// Implemented by subclasses.` > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:426 > + if (!contentView.constructor.shouldDetachWhenHidden && contentView.isAttached) Why `.constructor.`? It seems like we wouldn't want that if a future ContentView subclass dynamically determined `shouldDetachWhenHidden`. > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:465 > + else if (!entry.contentView.constructor.shouldDetachWhenHidden) { Ditto :426 > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:466 > + entry.contentView.element.classList.remove("hidden-for-detach"); `hidden-simulating-dom-detached`? The current class name doesn't quite sound right to me since we aren't actually detaching the view. > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:484 > + if (entry.contentView.constructor.shouldDetachWhenHidden) Ditto :426 > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:487 > + entry.contentView.element.classList.add("hidden-for-detach"); Ditto :466 > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:488 > + entry.contentView.detached(); See ContentView.js:380 - having the check be `entry.contentView.shouldDetachWhenHidden` and only calling `detached` here when the former is false isn't intuitive. A better name would help this. > Source/WebInspectorUI/UserInterface/Views/WebInspectorExtensionTabContentView.js:65 > + // Protected This is marked as `// Public` in the superclass, and will be read by other classes, so protected doesn't make sense here. > Tools/TestWebKitAPI/Tests/WebKitCocoa/InspectorExtension-basic-tab.html:15 > + // Used by WKInspectorExtension.ExtensionTabIsPersistent > + window.getUniqueValue = function() { > + if (!window._cachedUniqueValue) { > + window._cachedUniqueValue = Math.floor(Math.random() * 10e9); > + document.getElementById("uniqueValueField").innerText = window._cachedUniqueValue; > + } > + > + return window._cachedUniqueValue; > + } I think this and the test itself might be easier to follow if the test started by calling something like `setUniqueValue()` that performed the first half of this logic, but with a stable value (e.g. `window.setUniqueValue(42)`), and then future tests just call window.getUniqueValue() and make sure it is the magic value the test set instead of the default undefined/TBD. > Tools/TestWebKitAPI/Tests/WebKitCocoa/WKInspectorExtension.mm:208 > + auto extensionDisplayName = @"SecondExtension"; Are the extensions persisting between tests requiring this extension to have a different name, source URL, etc.? If so it seems like we may want tests to clean up after themselves - if not, why the change from `FirstExtension` to `SecondExtension` here? > Tools/TestWebKitAPI/Tests/WebKitCocoa/WKInspectorExtension.mm:248 > + auto scriptSource = @"!!window.getUniqueValue && window.getUniqueValue()"; See InspectorExtension-basic-tab.html:7-15 1799482 4 439785 hi 2021-10-01 12:57:20 -0700 Comment on attachment 439785 Patch v1.0 View in context: https://bugs.webkit.org/attachment.cgi?id=439785&action=review >> Source/WebInspectorUI/ChangeLog:25 >> + (WI.ContentView.prototype.get shouldDetachWhenHidden): Add new static getter, default is `true`. > > If this is supposed to be static, it should probably be in a separate section of the class from the overridable instance variables? I left some comments below before I looped back to this one, but I also left a comment on ContentViewContainer.js:426 making the argument that this shouldn't be treated as static, even if currently no implementation dynamically determines this. I think "static" was meant more as a "never changes" instead of "defined on the class object instead of per-instance". This is how most of the other `WI.ContentView` things are done. In this case tho I do kinda agree that maybe this should be a `static` method (or at least have some sort of comment explaining that this should not change at runtime) so that we never run into a scenario where it's `false` when the `WI.ContentView` is removed and then somehow `true` when it's added back (which could trigger some assertions about the `WI.View` already being parented). > Source/WebInspectorUI/UserInterface/Debug/Bootstrap.js:153 > + if (WI.sharedApp.extensionController.registeredExtensions.has(mockData.extensionID)) Instead of `get registeredExtensions` can we make a `isValidExtensionID()` so that we don't have to expose the internally used `Map` (this would also be a little more efficient as we wouldn't need to copy the `.keys()` to a `Set`)? >> Source/WebInspectorUI/UserInterface/Views/ContentView.js:380 >> + // Returns false if the content view should *not* be detached from the DOM when hidden. > > NIT: This comment could probably be replaced with a slightly more descriptive name instead, e.g. `shouldRemoveFromDOMWhenHidden` > NIT: Should have a comment `// Implemented by subclasses.` +1 to both of these also see my comment above > Source/WebInspectorUI/UserInterface/Views/ContentView.js:381 > + return true; NIT: We normally prefer optional things default to a falsy value, so maybe we could rename this to keep that trend? How about `shouldNotRemoveFromDOM`? > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.css:41 > +.content-view-container > .content-view.hidden-for-detach { Is this a specific enough selector? Do we need to add an `!important` (yuck, but perhaps the least bad option)? > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.css:42 > + display: none; Style: extra space >> Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:426 >> + if (!contentView.constructor.shouldDetachWhenHidden && contentView.isAttached) > > Why `.constructor.`? It seems like we wouldn't want that if a future ContentView subclass dynamically determined `shouldDetachWhenHidden`. This also doesn't make sense as `shouldNotRemoveFromDOM` is not `static`, meaning that it'll never be defined on `WI.ContentView` (the constructor object). >> Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:488 >> + entry.contentView.detached(); > > See ContentView.js:380 - having the check be `entry.contentView.shouldDetachWhenHidden` and only calling `detached` here when the former is false isn't intuitive. A better name would help this. Yeah I dislike using the term "detached" since it's been overloaded by the whole `WI.View` system to mean something other than "not part of the main DOM tree". Also, this is kinda slightly misleading since `entry.contentView.isAttached` will still be `true` since `entry.contentView._didMoveToParent(null)` was never called. Perhaps `shouldNotRemoveFromDOM` should really be defined on `WI.View` so that this logic can be done inside `WI.View.prototype.addSubview` and `WI.View.prototype.removeSubview` instead, especially since there's really nothing about `shouldNotRemoveFromDOM` that's specific to `WI.ContentView` (i.e. I could see this being useful for other non-`WI.ContentView` things too). > Tools/TestWebKitAPI/Tests/WebKitCocoa/WKInspectorExtension.mm:262 > + [[webView _inspector] showConsole]; NIT: Does this actually jump to the Console Tab or just show the Split Console? Perhaps we should use `-showResource` instead in case that behavior changes in the future. 1800082 5 439785 bburg 2021-10-04 09:04:17 -0700 Comment on attachment 439785 Patch v1.0 View in context: https://bugs.webkit.org/attachment.cgi?id=439785&action=review >>> Source/WebInspectorUI/ChangeLog:25 >>> + (WI.ContentView.prototype.get shouldDetachWhenHidden): Add new static getter, default is `true`. >> >> If this is supposed to be static, it should probably be in a separate section of the class from the overridable instance variables? I left some comments below before I looped back to this one, but I also left a comment on ContentViewContainer.js:426 making the argument that this shouldn't be treated as static, even if currently no implementation dynamically determines this. > > I think "static" was meant more as a "never changes" instead of "defined on the class object instead of per-instance". This is how most of the other `WI.ContentView` things are done. > > In this case tho I do kinda agree that maybe this should be a `static` method (or at least have some sort of comment explaining that this should not change at runtime) so that we never run into a scenario where it's `false` when the `WI.ContentView` is removed and then somehow `true` when it's added back (which could trigger some assertions about the `WI.View` already being parented). I changed it to a static method. Sorry about the confusion. >> Source/WebInspectorUI/UserInterface/Debug/Bootstrap.js:153 >> + if (WI.sharedApp.extensionController.registeredExtensions.has(mockData.extensionID)) > > Instead of `get registeredExtensions` can we make a `isValidExtensionID()` so that we don't have to expose the internally used `Map` (this would also be a little more efficient as we wouldn't need to copy the `.keys()` to a `Set`)? I don't understand the problem–the Map itself can't be mutated by the client, and the returned values are string keys copied from an iterator. I do think this would be problematic if the iterator came from the Map itself. This is Bootstrap.js code in engineering builds only so I'm not worried about efficiency for efficiency's sake. (Also I use this as a dumper for debugging and logging pretty often.) >> Source/WebInspectorUI/UserInterface/Views/ContentView.js:381 >> + return true; > > NIT: We normally prefer optional things default to a falsy value, so maybe we could rename this to keep that trend? How about `shouldNotRemoveFromDOM`? OK, I knew this but couldn't come up with an appropriate name. Thanks! >>> Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:488 >>> + entry.contentView.detached(); >> >> See ContentView.js:380 - having the check be `entry.contentView.shouldDetachWhenHidden` and only calling `detached` here when the former is false isn't intuitive. A better name would help this. > > Yeah I dislike using the term "detached" since it's been overloaded by the whole `WI.View` system to mean something other than "not part of the main DOM tree". > > Also, this is kinda slightly misleading since `entry.contentView.isAttached` will still be `true` since `entry.contentView._didMoveToParent(null)` was never called. Perhaps `shouldNotRemoveFromDOM` should really be defined on `WI.View` so that this logic can be done inside `WI.View.prototype.addSubview` and `WI.View.prototype.removeSubview` instead, especially since there's really nothing about `shouldNotRemoveFromDOM` that's specific to `WI.ContentView` (i.e. I could see this being useful for other non-`WI.ContentView` things too). I wanted to keep this conceptually as part of the ContentViewContainer system. If there is a concrete reason to make it more generic then let me know. I just don't have time to over-build and test this functionality outside of the tabs / ContentViewContainer use case. >> Tools/TestWebKitAPI/Tests/WebKitCocoa/InspectorExtension-basic-tab.html:15 >> + } > > I think this and the test itself might be easier to follow if the test started by calling something like `setUniqueValue()` that performed the first half of this logic, but with a stable value (e.g. `window.setUniqueValue(42)`), and then future tests just call window.getUniqueValue() and make sure it is the magic value the test set instead of the default undefined/TBD. I considered doing that. This is what the other test case does. However, if the <iframe> has loaded about:blank (the previous buggy behavior upon hiding) then setting and getting the value will work as expected, and yet a major bug will not be detected (wrong page has loaded into the iframe). >> Tools/TestWebKitAPI/Tests/WebKitCocoa/WKInspectorExtension.mm:208 >> + auto extensionDisplayName = @"SecondExtension"; > > Are the extensions persisting between tests requiring this extension to have a different name, source URL, etc.? If so it seems like we may want tests to clean up after themselves - if not, why the change from `FirstExtension` to `SecondExtension` here? The call to -unregisterExtension will clean up. Besides, each of these tests creates a fresh WKWebView / _WKInspector, and the set of _WKInspectorExtension currently active is not persisted anywhere in WebInspectorUI. The use of different names is to make it easier to keep track of what test is actually running when remote inspecting TestWebKitAPI. >> Tools/TestWebKitAPI/Tests/WebKitCocoa/WKInspectorExtension.mm:262 >> + [[webView _inspector] showConsole]; > > NIT: Does this actually jump to the Console Tab or just show the Split Console? Perhaps we should use `-showResource` instead in case that behavior changes in the future. It jumps to the Console Tab. I considered renaming to showConsoleTab, but it would require Safari changes. It's not worth the trouble IMO. If the behavior of -showConsole changes in the future such that didHideExtensionTabWasCalled no longer fires, then this test will need to be amended in order to pass. 1800136 6 440080 bburg 2021-10-04 11:20:38 -0700 Created attachment 440080 Patch v1.1 1800143 7 440080 pangle 2021-10-04 11:35:22 -0700 Comment on attachment 440080 Patch v1.1 View in context: https://bugs.webkit.org/attachment.cgi?id=440080&action=review Provisional r+ from me with a few NITs. > Source/WebInspectorUI/UserInterface/Views/ContentView.js:45 > + // Implemented by subclasses. NIT: This comment should be inside the method like below for the public overridables. > Source/WebInspectorUI/UserInterface/Views/WebInspectorExtensionTabContentView.js:66 > + // This is necessary to avoid the <iframe> content from being reloaded when the extension tab is hidden. > + static shouldNotRemoveFromDOMWhenHidden() { return true; } NIT: Should probably put this below with `static shouldSaveTab()` to keep the static functions together. > Source/WebInspectorUI/UserInterface/Views/WebInspectorExtensionTabContentView.js:68 > + // Protected Aren't `attached` and `detached` public? 1800200 8 440080 hi 2021-10-04 13:24:47 -0700 Comment on attachment 440080 Patch v1.1 View in context: https://bugs.webkit.org/attachment.cgi?id=440080&action=review > Source/WebInspectorUI/UserInterface/Controllers/WebInspectorExtensionController.js:40 > + get registeredExtensions() NIT: `registeredExtensionIDs` > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:426 > + if (contentView.constructor.shouldNotRemoveFromDOMWhenHidden() && contentView.isAttached) `contentView.isAttached` will _always_ be true for something that is `shouldNotRemoveFromDOMWhenHidden` since nothing ever calls `contentView._didMoveToParent(null)` which means that `_isAttachedToRoot` is still `true` perhaps instead of manually calling `attached()` and `detached()` you could `contentView._didMoveToParent(this)` and `contentView._didMoveToParent(null)`? though this would be using a "private" function outside of the owner class :/ this also may run into issues since we're still leaving the `contentView` inside `this._subviews` >> Source/WebInspectorUI/UserInterface/Views/WebInspectorExtensionTabContentView.js:66 >> + static shouldNotRemoveFromDOMWhenHidden() { return true; } > > NIT: Should probably put this below with `static shouldSaveTab()` to keep the static functions together. also please put the comment inside the function not above it 1800225 9 440080 bburg 2021-10-04 14:30:07 -0700 Comment on attachment 440080 Patch v1.1 View in context: https://bugs.webkit.org/attachment.cgi?id=440080&action=review >> Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:426 >> + if (contentView.constructor.shouldNotRemoveFromDOMWhenHidden() && contentView.isAttached) > > `contentView.isAttached` will _always_ be true for something that is `shouldNotRemoveFromDOMWhenHidden` since nothing ever calls `contentView._didMoveToParent(null)` which means that `_isAttachedToRoot` is still `true` > > perhaps instead of manually calling `attached()` and `detached()` you could `contentView._didMoveToParent(this)` and `contentView._didMoveToParent(null)`? though this would be using a "private" function outside of the owner class :/ > > this also may run into issues since we're still leaving the `contentView` inside `this._subviews` I think it's OK to drop the `contentView.isAttached` check as it is not necessary. I avoided calling _didMoveToParent() because that is what eventually attaches/detaches elements from the DOM. 1800706 10 440080 hi 2021-10-05 12:35:57 -0700 Comment on attachment 440080 Patch v1.1 View in context: https://bugs.webkit.org/attachment.cgi?id=440080&action=review > Source/WebInspectorUI/UserInterface/Views/ContentView.js:46 > + static shouldNotRemoveFromDOMWhenHidden() NIT: I just realized, I feel like we maybe should make this into a `static get` so that it's even more "hinted" at being something that shouldn't have any complicated work inside it >>> Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:426 >>> + if (contentView.constructor.shouldNotRemoveFromDOMWhenHidden() && contentView.isAttached) >> >> `contentView.isAttached` will _always_ be true for something that is `shouldNotRemoveFromDOMWhenHidden` since nothing ever calls `contentView._didMoveToParent(null)` which means that `_isAttachedToRoot` is still `true` >> >> perhaps instead of manually calling `attached()` and `detached()` you could `contentView._didMoveToParent(this)` and `contentView._didMoveToParent(null)`? though this would be using a "private" function outside of the owner class :/ >> >> this also may run into issues since we're still leaving the `contentView` inside `this._subviews` > > I think it's OK to drop the `contentView.isAttached` check as it is not necessary. > > I avoided calling _didMoveToParent() because that is what eventually attaches/detaches elements from the DOM. Unless I'm reading it wrong, I'm pretty sure the code that adds/removes from the DOM is actually inside `insertSubviewBefore`/`removeSubview`. `_didMoveToParent` just handles the `WI.View` logic of keeping track of dirty counts and pending layouts and whatnot. 1800725 11 440080 bburg 2021-10-05 13:17:53 -0700 Comment on attachment 440080 Patch v1.1 View in context: https://bugs.webkit.org/attachment.cgi?id=440080&action=review >> Source/WebInspectorUI/UserInterface/Controllers/WebInspectorExtensionController.js:40 >> + get registeredExtensions() > > NIT: `registeredExtensionIDs` Good catch >> Source/WebInspectorUI/UserInterface/Views/ContentView.js:46 >> + static shouldNotRemoveFromDOMWhenHidden() > > NIT: I just realized, I feel like we maybe should make this into a `static get` so that it's even more "hinted" at being something that shouldn't have any complicated work inside it I'd prefer it remain a static method like other ContentView / View opt-ins. If you'd like to update the prevailing style everywhere, I wouldn't stop you. >>>> Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:426 >>>> + if (contentView.constructor.shouldNotRemoveFromDOMWhenHidden() && contentView.isAttached) >>> >>> `contentView.isAttached` will _always_ be true for something that is `shouldNotRemoveFromDOMWhenHidden` since nothing ever calls `contentView._didMoveToParent(null)` which means that `_isAttachedToRoot` is still `true` >>> >>> perhaps instead of manually calling `attached()` and `detached()` you could `contentView._didMoveToParent(this)` and `contentView._didMoveToParent(null)`? though this would be using a "private" function outside of the owner class :/ >>> >>> this also may run into issues since we're still leaving the `contentView` inside `this._subviews` >> >> I think it's OK to drop the `contentView.isAttached` check as it is not necessary. >> >> I avoided calling _didMoveToParent() because that is what eventually attaches/detaches elements from the DOM. > > Unless I'm reading it wrong, I'm pretty sure the code that adds/removes from the DOM is actually inside `insertSubviewBefore`/`removeSubview`. `_didMoveToParent` just handles the `WI.View` logic of keeping track of dirty counts and pending layouts and whatnot. Oops, you are right. I must have misunderstood what was going on while hacking. I will replace attached() and detached(). >>> Source/WebInspectorUI/UserInterface/Views/WebInspectorExtensionTabContentView.js:66 >>> + static shouldNotRemoveFromDOMWhenHidden() { return true; } >> >> NIT: Should probably put this below with `static shouldSaveTab()` to keep the static functions together. > > also please put the comment inside the function not above it OK >> Source/WebInspectorUI/UserInterface/Views/WebInspectorExtensionTabContentView.js:68 >> + // Protected > > Aren't `attached` and `detached` public? OK 1800727 12 440255 bburg 2021-10-05 13:25:13 -0700 Created attachment 440255 Patch v1.2 Patch v1.2 addresses all outstanding comments. 1800738 13 440255 pangle 2021-10-05 13:53:59 -0700 Comment on attachment 440255 Patch v1.2 View in context: https://bugs.webkit.org/attachment.cgi?id=440255&action=review > Source/WebInspectorUI/UserInterface/Views/ContentView.js:45 > + // Implemented by subclasses. NIT: Put this inside the function. > Source/WebInspectorUI/UserInterface/Views/WebInspectorExtensionTabContentView.js:92 > + NIT: Extra newline 1801163 14 440255 bburg 2021-10-06 10:26:20 -0700 Comment on attachment 440255 Patch v1.2 View in context: https://bugs.webkit.org/attachment.cgi?id=440255&action=review >> Source/WebInspectorUI/UserInterface/Views/ContentView.js:45 >> + // Implemented by subclasses. > > NIT: Put this inside the function. OK 1801664 15 440514 bburg 2021-10-07 10:54:52 -0700 Created attachment 440514 Patch v1.2.1 (for landing) 1801688 16 ews-feeder 2021-10-07 11:38:19 -0700 Committed r283728 (242652@main): <https://commits.webkit.org/242652@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 440514. 1801736 17 440514 hi 2021-10-07 13:00:31 -0700 Comment on attachment 440514 Patch v1.2.1 (for landing) View in context: https://bugs.webkit.org/attachment.cgi?id=440514&action=review > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:467 > + entry.contentView._didMoveToParent(this); this is technically a private violation since this method is not public FWIW i'd suggested moving the logic to `WI.View` to avoid this can you file a bug for fixing this please? > Source/WebInspectorUI/UserInterface/Views/ContentViewContainer.js:486 > + entry.contentView._didMoveToParent(null); ditto (:467) 439785 2021-09-30 15:35:00 -0700 2021-10-04 11:20:36 -0700 Patch v1.0 bug-230758-20210930153459.patch text/plain 17875 bburg U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzMTg3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkluc3BlY3RvclVJL0NoYW5nZUxvZwppbmRleCA3 OGY4NjAzYTk3MDlmNDdlYWVjYTY3M2M3YzgwYWIzYjRmYThmZTY1Li4xYjg0NDViNTYzNTY4N2Q4 NDQ4MGI1NjNmM2FiMWJmMDllOTYxOTcxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9y VUkvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKQEAgLTEs MyArMSw0NCBAQAorMjAyMS0wOS0zMCAgQkogQnVyZyAgPGJidXJnQGFwcGxlLmNvbT4KKworICAg ICAgICBXZWIgSW5zcGVjdG9yOiBXZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50VmlldyBz aG91bGQgbm90IHJlbG9hZCBpdHMgaWZyYW1lIHdoZW4gZGV0YWNoZWQKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzMDc1OAorICAgICAgICA8cmRhcjov Lzc0NzE0ODYxPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIFdoZW4gYW4gPGlmcmFtZT4gZWxlbWVudCBkZXRhY2hlcyBmcm9tIHRoZSBET00sIHRoZSBz Y3JpcHQgY29udGV4dCBpcyBkZXN0cm95ZWQsIHdoaWNoIHdlIGRvbid0CisgICAgICAgIHdhbnQg dG8gaGFwcGVuIGZvciBfV0tJbnNwZWN0b3JFeHRlbnNpb24gdGFicy4gRml4IHRoaXMgYnkgdGVh Y2hpbmcgQ29udGVudFZpZXdDb250YWluZXIgdG8KKyAgICAgICAgJ2hpZGUnIHN1Y2ggY29udGVu dCB2aWV3cyBieSBzZXR0aW5nIGBkaXNwbGF5Om5vbmVgIHJhdGhlciB0aGFuIGRldGFjaGluZyBm cm9tIHRoZSBET00uCisKKyAgICAgICAgKiBVc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3 Q29udGFpbmVyLmpzOgorICAgICAgICAoV0kuQ29udGVudFZpZXdDb250YWluZXIucHJvdG90eXBl Ll9zaG93RW50cnkpOgorICAgICAgICAoV0kuQ29udGVudFZpZXdDb250YWluZXIucHJvdG90eXBl Ll9oaWRlRW50cnkpOgorICAgICAgICBTZXQgYW5kIHVuc2V0ICdkaXNwbGF5Om5vbmUnIGluc3Rl YWQgb2YgY2FsbGluZyBhZGRTdWJ2aWV3KCkgLyByZW1vdmVTdWJ2aWV3KCkuCisKKyAgICAgICAg KiBVc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmNzczoKKyAgICAgICAg KC5jb250ZW50LXZpZXctY29udGFpbmVyID4gLmNvbnRlbnQtdmlldy5oaWRkZW4tZm9yLWRldGFj aCk6IEFkZGVkLgorCisgICAgICAgIChXSS5Db250ZW50Vmlld0NvbnRhaW5lci5wcm90b3R5cGUu X2Rpc2Fzc29jaWF0ZUZyb21Db250ZW50Vmlldyk6CisgICAgICAgIENsZWFuIHVwIGFueSByZW1h aW5pbmcgY29udGVudCB2aWV3cyB0aGF0IHdlcmUgbm90IGRldGFjaGVkIGR1ZSB0byBvdmVycmlk aW5nIHNob3VsZERldGFjaFdoZW5IaWRkZW4uCisKKyAgICAgICAgKiBVc2VySW50ZXJmYWNlL1Zp ZXdzL0NvbnRlbnRWaWV3LmpzOgorICAgICAgICAoV0kuQ29udGVudFZpZXcucHJvdG90eXBlLmdl dCBzaG91bGREZXRhY2hXaGVuSGlkZGVuKTogQWRkIG5ldyBzdGF0aWMgZ2V0dGVyLCBkZWZhdWx0 IGlzIGB0cnVlYC4KKworICAgICAgICAqIFVzZXJJbnRlcmZhY2UvVmlld3MvV2ViSW5zcGVjdG9y RXh0ZW5zaW9uVGFiQ29udGVudFZpZXcuanM6CisgICAgICAgIChXSS5XZWJJbnNwZWN0b3JFeHRl bnNpb25UYWJDb250ZW50Vmlldyk6CisgICAgICAgIChXSS5XZWJJbnNwZWN0b3JFeHRlbnNpb25U YWJDb250ZW50Vmlldy5wcm90b3R5cGUuZ2V0IHNob3VsZERldGFjaFdoZW5IaWRkZW4pOgorICAg ICAgICBPdmVycmlkZSB0aGlzIHRvIG9wdCBpbnRvIHRoZSBhbHRlcm5hdGUgYmVoYXZpb3IgdGhh dCBkb2VzIG5vdCBkZXRhY2ggZnJvbSB0aGUgRE9NLiBJdCBpcyBzdGlsbAorICAgICAgICBuZWNl c3NhcnkgdG8gY2FsbCBhdHRhY2hlZCgpIGFuZCBkZXRhY2hlZCgpIHNvIHRoYXQgV2ViSW5wZWN0 b3JFeHRlbnNpb25UYWJDb250ZW50VmlldyBjYW4gZ2VuZXJhdGUKKyAgICAgICAgZGlkU2hvd0V4 dGVuc2lvblRhYi9kaWRIaWRlRXh0ZW5zaW9uVGFiIGV2ZW50IGNhbGxiYWNrcy4KKworICAgICAg ICAqIFVzZXJJbnRlcmZhY2UvQ29udHJvbGxlcnMvV2ViSW5zcGVjdG9yRXh0ZW5zaW9uQ29udHJv bGxlci5qczoKKyAgICAgICAgKFdJLldlYkluc3BlY3RvckV4dGVuc2lvbkNvbnRyb2xsZXIucHJv dG90eXBlLmdldCByZWdpc3RlcmVkRXh0ZW5zaW9ucyk6CisgICAgICAgICogVXNlckludGVyZmFj ZS9EZWJ1Zy9Cb290c3RyYXAuanM6CisgICAgICAgICh1cGRhdGVNb2NrV2ViRXh0ZW5zaW9uVGFi KToKKyAgICAgICAgKFdJLnJ1bkJvb3RzdHJhcE9wZXJhdGlvbnMpOgorICAgICAgICBUaGlzIGlz IGEgZHJpdmUtYnkgZml4IHRvIGFkZHJlc3MgYSBjb25zb2xlIGFzc2VydGlvbiBzZWVuIHdoaWxl IGRldmVsb3BpbmcgdGhlIEFQSSB0ZXN0LgorICAgICAgICBEb24ndCB1bnJlZ2lzdGVyIHRoZSBt b2NrIGV4dGVuc2lvbiBpZiBpdCBpcyBub3QgcmVnaXN0ZXJlZCBpbiB0aGUgZmlyc3QgcGxhY2Uu CisKIDIwMjEtMDktMjggIEJKIEJ1cmcgIDxiYnVyZ0BhcHBsZS5jb20+CiAKICAgICAgICAgV2Vi IEluc3BlY3RvcjogYWRkIHNldHRpbmdzIG9wdGlvbiBmb3IgJ1Nob3cgTW9jayBXZWIgRXh0ZW5z aW9uIFRhYicgaW4gZW5naW5lZXJpbmcgYnVpbGRzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5z cGVjdG9yVUkvVXNlckludGVyZmFjZS9Db250cm9sbGVycy9XZWJJbnNwZWN0b3JFeHRlbnNpb25D b250cm9sbGVyLmpzIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvQ29udHJv bGxlcnMvV2ViSW5zcGVjdG9yRXh0ZW5zaW9uQ29udHJvbGxlci5qcwppbmRleCA1NzViNDA4Mjdj NTE3ZDJhYWU3NTY2OWQwMjVlMjk5Yjg5N2M1OGYwLi4zOGEzNzljNGQ4YWU4MWI1ZmNmMDZmZWE3 MjJhYmM2OGFlYzc4YjhjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlcklu dGVyZmFjZS9Db250cm9sbGVycy9XZWJJbnNwZWN0b3JFeHRlbnNpb25Db250cm9sbGVyLmpzCisr KyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL0NvbnRyb2xsZXJzL1dlYklu c3BlY3RvckV4dGVuc2lvbkNvbnRyb2xsZXIuanMKQEAgLTM3LDYgKzM3LDExIEBAIFdJLldlYklu c3BlY3RvckV4dGVuc2lvbkNvbnRyb2xsZXIgPSBjbGFzcyBXZWJJbnNwZWN0b3JFeHRlbnNpb25D b250cm9sbGVyIGV4dGVuCiAKICAgICAvLyBQdWJsaWMKIAorICAgIGdldCByZWdpc3RlcmVkRXh0 ZW5zaW9ucygpCisgICAgeworICAgICAgICByZXR1cm4gbmV3IFNldCh0aGlzLl9leHRlbnNpb25G b3JFeHRlbnNpb25JRE1hcC5rZXlzKCkpOworICAgIH0KKwogICAgIHJlZ2lzdGVyRXh0ZW5zaW9u KGV4dGVuc2lvbklELCBkaXNwbGF5TmFtZSkKICAgICB7CiAgICAgICAgIGlmICh0aGlzLl9leHRl bnNpb25Gb3JFeHRlbnNpb25JRE1hcC5oYXMoZXh0ZW5zaW9uSUQpKSB7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9EZWJ1Zy9Cb290c3RyYXAuanMgYi9T b3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9EZWJ1Zy9Cb290c3RyYXAuanMKaW5k ZXggOGQ0NDAzNmViYTNjZGQ1YjBhZjU2MTkyNTQyYmQxZDU3NTVjOTYxNi4uZDg4OGUyMDc0ZDhk ZTdiNjAxMGM3NmIzNWY3Mzg3YTRhNmM0NTU2ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3Bl Y3RvclVJL1VzZXJJbnRlcmZhY2UvRGVidWcvQm9vdHN0cmFwLmpzCisrKyBiL1NvdXJjZS9XZWJJ bnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL0RlYnVnL0Jvb3RzdHJhcC5qcwpAQCAtMTUwLDcgKzE1 MCw5IEBAIFdJLnJ1bkJvb3RzdHJhcE9wZXJhdGlvbnMgPSBmdW5jdGlvbigpIHsKIAogICAgICAg ICAvLyBTaW11bGF0ZXMgdGhlIHN0ZXBzIHRha2VuIGJ5IFdlYkluc3BlY3RvclVJRXh0ZW5zaW9u Q29udHJvbGxlciB0byBjcmVhdGUgYW4gZXh0ZW5zaW9uIHRhYiBpbiBXZWJJbnNwZWN0b3JVSS4K ICAgICAgICAgaWYgKCFXSS5zZXR0aW5ncy5lbmdpbmVlcmluZ1Nob3dNb2NrV2ViRXh0ZW5zaW9u VGFiLnZhbHVlKSB7Ci0gICAgICAgICAgICBJbnNwZWN0b3JGcm9udGVuZEFQSS51bnJlZ2lzdGVy RXh0ZW5zaW9uKG1vY2tEYXRhLmV4dGVuc2lvbklEKTsKKyAgICAgICAgICAgIGlmIChXSS5zaGFy ZWRBcHAuZXh0ZW5zaW9uQ29udHJvbGxlci5yZWdpc3RlcmVkRXh0ZW5zaW9ucy5oYXMobW9ja0Rh dGEuZXh0ZW5zaW9uSUQpKQorICAgICAgICAgICAgICAgIEluc3BlY3RvckZyb250ZW5kQVBJLnVu cmVnaXN0ZXJFeHRlbnNpb24obW9ja0RhdGEuZXh0ZW5zaW9uSUQpOworCiAgICAgICAgICAgICBy ZXR1cm47CiAgICAgICAgIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1Vz ZXJJbnRlcmZhY2UvVmlld3MvQ29udGVudFZpZXcuanMgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkv VXNlckludGVyZmFjZS9WaWV3cy9Db250ZW50Vmlldy5qcwppbmRleCAwNTM5YTVmZTQ0MTA0M2Uz ODUwNzM3YzJlYTE1MDQ0ZWFhZmE3YzhkLi5kNDMzN2QyNWI4NGRiYTE3MTA3ZTJlNzVhMTMwMjI4 MTEzMmRlYmQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFj ZS9WaWV3cy9Db250ZW50Vmlldy5qcworKysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlcklu dGVyZmFjZS9WaWV3cy9Db250ZW50Vmlldy5qcwpAQCAtMzc1LDYgKzM3NSwxMiBAQCBXSS5Db250 ZW50VmlldyA9IGNsYXNzIENvbnRlbnRWaWV3IGV4dGVuZHMgV0kuVmlldwogICAgICAgICByZXR1 cm4gZmFsc2U7CiAgICAgfQogCisgICAgZ2V0IHNob3VsZERldGFjaFdoZW5IaWRkZW4oKQorICAg IHsKKyAgICAgICAgLy8gUmV0dXJucyBmYWxzZSBpZiB0aGUgY29udGVudCB2aWV3IHNob3VsZCAq bm90KiBiZSBkZXRhY2hlZCBmcm9tIHRoZSBET00gd2hlbiBoaWRkZW4uCisgICAgICAgIHJldHVy biB0cnVlOworICAgIH0KKwogICAgIGdldCBzZWxlY3Rpb25QYXRoQ29tcG9uZW50cygpCiAgICAg ewogICAgICAgICAvLyBJbXBsZW1lbnRlZCBieSBzdWJjbGFzc2VzLgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvVmlld3MvQ29udGVudFZpZXdDb250YWlu ZXIuY3NzIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvVmlld3MvQ29udGVu dFZpZXdDb250YWluZXIuY3NzCmluZGV4IDNiZWFiMWE4YzU1MDE5M2U4YjA1NjUxOGUwNjJhYzJk OTU2MDQ4YzEuLjY2MDhjNGNjNTVhOGFlNGY2YTI1NzkxYzYwMzdkZTRiNzFmYmFlMzUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRW aWV3Q29udGFpbmVyLmNzcworKysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFj ZS9WaWV3cy9Db250ZW50Vmlld0NvbnRhaW5lci5jc3MKQEAgLTEsNSArMSw1IEBACiAvKgotICog Q29weXJpZ2h0IChDKSAyMDEzIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENv cHlyaWdodCAoQykgMjAxMywgMjAyMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAg KgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTM3LDMgKzM3LDcgQEAKIAogICAgIG92 ZXJmbG93OiBoaWRkZW47CiB9CisKKy5jb250ZW50LXZpZXctY29udGFpbmVyID4gLmNvbnRlbnQt dmlldy5oaWRkZW4tZm9yLWRldGFjaCB7CisgICAgZGlzcGxheTogIG5vbmU7Cit9CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9Db250ZW50Vmll d0NvbnRhaW5lci5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdz L0NvbnRlbnRWaWV3Q29udGFpbmVyLmpzCmluZGV4IGFiMDU2ZWY5MzUyMTVhZDA5MDQzYTg3ZmM5 NzYyMGJjN2U4NGYwNTAuLjdlYzI3NGI0MDAyZTM4NTg2Y2I0MTVlNmViZjM0NTQwM2EzYTVlMzUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0Nv bnRlbnRWaWV3Q29udGFpbmVyLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50 ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmpzCkBAIC00MjEsNiArNDIxLDExIEBA IFdJLkNvbnRlbnRWaWV3Q29udGFpbmVyID0gY2xhc3MgQ29udGVudFZpZXdDb250YWluZXIgZXh0 ZW5kcyBXSS5WaWV3CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KIAorICAgICAgICAv LyBEZXNlbGVjdGVkIGV4dGVuc2lvbiB0YWJzIGFyZSBzdGlsbCBhdHRhY2hlZCB0byB0aGUgRE9N IHZpYSBgdGhpcy5lbGVtZW50YCwKKyAgICAgICAgLy8gc28gdGhpcyBpcyB0aGUgbGFzdCBjaGFu Y2UgdG8gcmVtb3ZlIHRoZSBzdWJ2aWV3IGFuZCBkZXRhY2ggZnJvbSB0aGUgRE9NLgorICAgICAg ICBpZiAoIWNvbnRlbnRWaWV3LmNvbnN0cnVjdG9yLnNob3VsZERldGFjaFdoZW5IaWRkZW4gJiYg Y29udGVudFZpZXcuaXNBdHRhY2hlZCkKKyAgICAgICAgICAgIHRoaXMucmVtb3ZlU3Vidmlldyhj b250ZW50Vmlldyk7CisKICAgICAgICAgY29uc29sZS5hc3NlcnQoIWNvbnRlbnRWaWV3LmlzQXR0 YWNoZWQpOwogCiAgICAgICAgIGlmICghY29udGVudFZpZXcuX3BhcmVudENvbnRhaW5lcikKQEAg LTQ1Nyw2ICs0NjIsMTAgQEAgV0kuQ29udGVudFZpZXdDb250YWluZXIgPSBjbGFzcyBDb250ZW50 Vmlld0NvbnRhaW5lciBleHRlbmRzIFdJLlZpZXcKIAogICAgICAgICBpZiAoIXRoaXMuc3Vidmll d3MuaW5jbHVkZXMoZW50cnkuY29udGVudFZpZXcpKQogICAgICAgICAgICAgdGhpcy5hZGRTdWJ2 aWV3KGVudHJ5LmNvbnRlbnRWaWV3KTsKKyAgICAgICAgZWxzZSBpZiAoIWVudHJ5LmNvbnRlbnRW aWV3LmNvbnN0cnVjdG9yLnNob3VsZERldGFjaFdoZW5IaWRkZW4pIHsKKyAgICAgICAgICAgIGVu dHJ5LmNvbnRlbnRWaWV3LmVsZW1lbnQuY2xhc3NMaXN0LnJlbW92ZSgiaGlkZGVuLWZvci1kZXRh Y2giKTsKKyAgICAgICAgICAgIGVudHJ5LmNvbnRlbnRWaWV3LmF0dGFjaGVkKCk7CisgICAgICAg IH0KIAogICAgICAgICBlbnRyeS5wcmVwYXJlVG9TaG93KCk7CiAgICAgfQpAQCAtNDcxLDggKzQ4 MCwxNCBAQCBXSS5Db250ZW50Vmlld0NvbnRhaW5lciA9IGNsYXNzIENvbnRlbnRWaWV3Q29udGFp bmVyIGV4dGVuZHMgV0kuVmlldwogICAgICAgICAgICAgcmV0dXJuOwogCiAgICAgICAgIGVudHJ5 LnByZXBhcmVUb0hpZGUoKTsKLSAgICAgICAgaWYgKHRoaXMuc3Vidmlld3MuaW5jbHVkZXMoZW50 cnkuY29udGVudFZpZXcpKQotICAgICAgICAgICAgdGhpcy5yZW1vdmVTdWJ2aWV3KGVudHJ5LmNv bnRlbnRWaWV3KTsKKyAgICAgICAgaWYgKHRoaXMuc3Vidmlld3MuaW5jbHVkZXMoZW50cnkuY29u dGVudFZpZXcpKSB7CisgICAgICAgICAgICBpZiAoZW50cnkuY29udGVudFZpZXcuY29uc3RydWN0 b3Iuc2hvdWxkRGV0YWNoV2hlbkhpZGRlbikKKyAgICAgICAgICAgICAgICB0aGlzLnJlbW92ZVN1 YnZpZXcoZW50cnkuY29udGVudFZpZXcpOworICAgICAgICAgICAgZWxzZSB7CisgICAgICAgICAg ICAgICAgZW50cnkuY29udGVudFZpZXcuZWxlbWVudC5jbGFzc0xpc3QuYWRkKCJoaWRkZW4tZm9y LWRldGFjaCIpOworICAgICAgICAgICAgICAgIGVudHJ5LmNvbnRlbnRWaWV3LmRldGFjaGVkKCk7 CisgICAgICAgICAgICB9CisgICAgICAgIH0KICAgICB9CiAKICAgICBfdG9tYnN0b25lQ29udGVu dFZpZXdDb250YWluZXJzRm9yQ29udGVudFZpZXcoY29udGVudFZpZXcpCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9XZWJJbnNwZWN0b3JFeHRl bnNpb25UYWJDb250ZW50Vmlldy5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJm YWNlL1ZpZXdzL1dlYkluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3LmpzCmluZGV4IDc0 YWZhNGNjZmJkMjhjZjYzNGIxODczNDhkMDY1NzBiNmViZTIwYWUuLjc4MTlkMjE0ZjQyN2M4MThh YzBkNzgxODZiZTc3ZTQwMmYwMjY4ODMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JV SS9Vc2VySW50ZXJmYWNlL1ZpZXdzL1dlYkluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3 LmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL1dlYklu c3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3LmpzCkBAIC00MCw5ICs0MCw2IEBAIFdJLldl Ykluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3ID0gY2xhc3MgV2ViSW5zcGVjdG9yRXh0 ZW5zaW9uVGFiQ29udGVudFZpCiAgICAgICAgIHRoaXMuX3RhYkluZm8gPSB0YWJJbmZvOwogICAg ICAgICB0aGlzLl9zb3VyY2VVUkwgPSBzb3VyY2VVUkw7CiAKLSAgICAgICAgLy8gRklYTUU6IHRo ZSA8aWZyYW1lPidzIGRvY3VtZW50IGlzIGltcGxpY2l0bHkgcmVsb2FkZWQgd2hlbiB0aGlzCi0g ICAgICAgIC8vIGNvbnRlbnQgdmlldydzIGVsZW1lbnQgaXMgZGV0YWNoZWQgYW5kIGxhdGVyIHJl LWF0dGFjaGVkIHRvIHRoZSBET00uCi0gICAgICAgIC8vIFRoaXMgaXMgYSBidWcgYW5kIHdpbGwg YmUgYWRkcmVzc2VkIGluIDxodHRwczovL3dlYmtpdC5vcmcvYi8yMzA3NTg+LgogICAgICAgICB0 aGlzLl9pZnJhbWVFbGVtZW50ID0gdGhpcy5lbGVtZW50LmFwcGVuZENoaWxkKGRvY3VtZW50LmNy ZWF0ZUVsZW1lbnQoImlmcmFtZSIpKTsKICAgICAgICAgdGhpcy5faWZyYW1lRWxlbWVudC5hZGRF dmVudExpc3RlbmVyKCJsb2FkIiwgdGhpcy5fZXh0ZW5zaW9uRnJhbWVEaWRMb2FkLmJpbmQodGhp cykpOwogICAgICAgICB0aGlzLl9pZnJhbWVFbGVtZW50LnNyYyA9IHRoaXMuX3NvdXJjZVVSTDsK QEAgLTY1LDYgKzYyLDEzIEBAIFdJLldlYkluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3 ID0gY2xhc3MgV2ViSW5zcGVjdG9yRXh0ZW5zaW9uVGFiQ29udGVudFZpCiAgICAgICAgIHJldHVy biB0cnVlOwogICAgIH0KIAorICAgIC8vIFByb3RlY3RlZAorCisgICAgZ2V0IHNob3VsZERldGFj aFdoZW5IaWRkZW4oKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKwogICAg IGF0dGFjaGVkKCkKICAgICB7CiAgICAgICAgIHN1cGVyLmF0dGFjaGVkKCk7CmRpZmYgLS1naXQg YS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggMjUwYzdmZjgyODZjM2U3 YTQ4ODk5ZDliN2VkYjFjZjQ3NWY5M2U2Ni4uZWY5Y2RhYzJhOGNhZTY3YTBlZGFlMTEwMDAxN2U3 YWY1YWY4MWY5MyAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIxLTA5LTMwICBCSiBCdXJnICA8YmJ1cmdAYXBwbGUu Y29tPgorCisgICAgICAgIFdlYiBJbnNwZWN0b3I6IFdlYkluc3BlY3RvckV4dGVuc2lvblRhYkNv bnRlbnRWaWV3IHNob3VsZCBub3QgcmVsb2FkIGl0cyBpZnJhbWUgd2hlbiBkZXRhY2hlZAorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjMwNzU4CisgICAg ICAgIDxyZGFyOi8vNzQ3MTQ4NjE+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgQWRkIGEgbmV3IHRlc3QgdG8gdmVyaWZ5IHRoYXQgcmUtc2VsZWN0aW5n IGFuIGV4dGVuc2lvbiB0YWIgZG9lcyBub3QgY2F1c2UgaXQgdG8gcmVsb2FkLgorCisgICAgICAg ICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9JbnNwZWN0b3JFeHRlbnNpb24tYmFz aWMtdGFiLmh0bWw6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9X S0luc3BlY3RvckV4dGVuc2lvbi5tbToKKyAgICAgICAgKFRFU1QpOgorCiAyMDIxLTA5LTI3ICBC SiBCdXJnICA8YmJ1cmdAYXBwbGUuY29tPgogCiAgICAgICAgIFtDb2NvYV0gYWRkIF9XS0luc3Bl Y3RvckV4dGVuc2lvbiBTUEkgdG8gZXZhbHVhdGUgc2NyaXB0IG9uIGFuIGV4dGVuc2lvbiB0YWIK ZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvSW5zcGVj dG9yRXh0ZW5zaW9uLWJhc2ljLXRhYi5odG1sIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9X ZWJLaXRDb2NvYS9JbnNwZWN0b3JFeHRlbnNpb24tYmFzaWMtdGFiLmh0bWwKaW5kZXggNDJiZjE5 ZDBiMjc3NTQyMTljNTIyZDdhM2FkMDhhMjljNGE1YTBlNC4uNmZhYTlmYjQwZjYwNTE0ZmVmYzNl YWU0YzEzZWNmN2ZiNGMyYjFmMCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJLaXRDb2NvYS9JbnNwZWN0b3JFeHRlbnNpb24tYmFzaWMtdGFiLmh0bWwKKysrIGIvVG9v bHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9JbnNwZWN0b3JFeHRlbnNpb24tYmFz aWMtdGFiLmh0bWwKQEAgLTEsMTAgKzEsMjQgQEAKIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0Pgor ICAgIC8vIFVzZWQgYnkgV0tJbnNwZWN0b3JFeHRlbnNpb24uQ2FuRXZhbHVhdGVTY3JpcHRJbkV4 dGVuc2lvblRhYgogICAgIHdpbmRvdy5fc2VjcmV0VmFsdWUgPSB7YW5zd2VyOjQyfTsKKworICAg IC8vIFVzZWQgYnkgV0tJbnNwZWN0b3JFeHRlbnNpb24uRXh0ZW5zaW9uVGFiSXNQZXJzaXN0ZW50 CisgICAgd2luZG93LmdldFVuaXF1ZVZhbHVlID0gZnVuY3Rpb24oKSB7CisgICAgICAgIGlmICgh d2luZG93Ll9jYWNoZWRVbmlxdWVWYWx1ZSkgeworICAgICAgICAgICAgd2luZG93Ll9jYWNoZWRV bmlxdWVWYWx1ZSA9IE1hdGguZmxvb3IoTWF0aC5yYW5kb20oKSAqIDEwZTkpOworICAgICAgICAg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInVuaXF1ZVZhbHVlRmllbGQiKS5pbm5lclRleHQg PSB3aW5kb3cuX2NhY2hlZFVuaXF1ZVZhbHVlOworICAgICAgICB9CisKKyAgICAgICAgcmV0dXJu IHdpbmRvdy5fY2FjaGVkVW5pcXVlVmFsdWU7CisgICAgfQogPC9zY3JpcHQ+CiA8Ym9keT4KIDxo MT5UaGlzIGlzIGEgdGVzdCBleHRlbnNpb24uPC9oMT4KIDxwPkluIGEgbm9ybWFsIGV4dGVuc2lv biwgdGhpcyBhcmVhIHdvdWxkIHNob3cgdGhlIGV4dGVuc2lvbidzIHVzZXIgaW50ZXJmYWNlLjwv cD4KKzxwPlRoZSB1bmlxdWUgdmFsdWUgZm9yIHRoaXMgaWZyYW1lJ3MgZXhlY3V0aW9uIGNvbnRl eHQgaXM6CisgICAgPHNwYW4gaWQ9InVuaXF1ZVZhbHVlRmllbGQiPlRCRDwvc3Bhbj4KKzwvcD4K IDwvYm9keT4KIDwvaHRtbD4KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Q29jb2EvV0tJbnNwZWN0b3JFeHRlbnNpb24ubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdENvY29hL1dLSW5zcGVjdG9yRXh0ZW5zaW9uLm1tCmluZGV4IDI0MjE3Mjg4 YzljZmMxMGY5NzViYzc3OGIxODQ1MjYwNzA0ZTkzOWYuLmE2NDA0NDNmNGViMzkxYmUzYjBjMTRm NGY0MmExYmI1ODQzZWEzMWEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Q29jb2EvV0tJbnNwZWN0b3JFeHRlbnNpb24ubW0KKysrIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9XS0luc3BlY3RvckV4dGVuc2lvbi5tbQpAQCAtNDcsNiAr NDcsNyBAQCBzdGF0aWMgYm9vbCBwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSBmYWxzZTsKIHN0 YXRpYyBSZXRhaW5QdHI8VGVzdEluc3BlY3RvclVSTFNjaGVtZUhhbmRsZXI+IHNoYXJlZFVSTFNj aGVtZUhhbmRsZXI7CiBzdGF0aWMgUmV0YWluUHRyPF9XS0luc3BlY3RvckV4dGVuc2lvbj4gc2hh cmVkSW5zcGVjdG9yRXh0ZW5zaW9uOwogc3RhdGljIFJldGFpblB0cjxOU1N0cmluZz4gc2hhcmVk RXh0ZW5zaW9uVGFiSWRlbnRpZmllcjsKK3N0YXRpYyBSZXRhaW5QdHI8TlNPYmplY3Q+IGV2YWx1 YXRpb25SZXN1bHQ7CiAKIHN0YXRpYyB2b2lkIHJlc2V0R2xvYmFsU3RhdGUoKQogewpAQCAtMTg4 LDQgKzE4OSwxMjEgQEAgVEVTVChXS0luc3BlY3RvckV4dGVuc2lvbiwgQ2FuRXZhbHVhdGVTY3Jp cHRJbkV4dGVuc2lvblRhYikKICAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJnBlbmRpbmdD YWxsYmFja1dhc0NhbGxlZCk7CiB9CiAKK1RFU1QoV0tJbnNwZWN0b3JFeHRlbnNpb24sIEV4dGVu c2lvblRhYklzUGVyc2lzdGVudCkKK3sKKyAgICByZXNldEdsb2JhbFN0YXRlKCk7CisKKyAgICBh dXRvIHdlYlZpZXdDb25maWd1cmF0aW9uID0gYWRvcHROUyhbV0tXZWJWaWV3Q29uZmlndXJhdGlv biBuZXddKTsKKyAgICB3ZWJWaWV3Q29uZmlndXJhdGlvbi5nZXQoKS5wcmVmZXJlbmNlcy5fZGV2 ZWxvcGVyRXh0cmFzRW5hYmxlZCA9IFlFUzsKKyAgICBhdXRvIHdlYlZpZXcgPSBhZG9wdE5TKFtb V0tXZWJWaWV3IGFsbG9jXSBpbml0V2l0aEZyYW1lOkNHUmVjdE1ha2UoMCwgMCwgODAwLCA2MDAp IGNvbmZpZ3VyYXRpb246d2ViVmlld0NvbmZpZ3VyYXRpb24uZ2V0KCldKTsKKyAgICBhdXRvIHVp RGVsZWdhdGUgPSBhZG9wdE5TKFtVSURlbGVnYXRlRm9yVGVzdGluZ0luc3BlY3RvckV4dGVuc2lv biBuZXddKTsKKworICAgIFt3ZWJWaWV3IHNldFVJRGVsZWdhdGU6dWlEZWxlZ2F0ZS5nZXQoKV07 CisgICAgW3dlYlZpZXcgbG9hZEhUTUxTdHJpbmc6QCI8aGVhZD48dGl0bGU+VGVzdCBwYWdlIHRv IGJlIGluc3BlY3RlZDwvdGl0bGU+PC9oZWFkPjxib2R5PjxwPkZpbGxlciBjb250ZW50PC9wPjwv Ym9keT4iIGJhc2VVUkw6W05TVVJMIFVSTFdpdGhTdHJpbmc6QCJodHRwOi8vZXhhbXBsZS5jb20v Il1dOworCisgICAgW1t3ZWJWaWV3IF9pbnNwZWN0b3JdIHNob3ddOworICAgIFRlc3RXZWJLaXRB UEk6OlV0aWw6OnJ1bigmZGlkQXR0YWNoTG9jYWxJbnNwZWN0b3JDYWxsZWQpOworCisgICAgYXV0 byBleHRlbnNpb25JRCA9IFtOU1VVSUQgVVVJRF0uVVVJRFN0cmluZzsKKyAgICBhdXRvIGV4dGVu c2lvbkRpc3BsYXlOYW1lID0gQCJTZWNvbmRFeHRlbnNpb24iOworCisgICAgLy8gUmVnaXN0ZXIg dGhlIHRlc3QgZXh0ZW5zaW9uLgorICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IGZhbHNl OworICAgIFtbd2ViVmlldyBfaW5zcGVjdG9yXSByZWdpc3RlckV4dGVuc2lvbldpdGhJRDpleHRl bnNpb25JRCBkaXNwbGF5TmFtZTpleHRlbnNpb25EaXNwbGF5TmFtZSBjb21wbGV0aW9uSGFuZGxl cjpeKE5TRXJyb3IgKiBfTnVsbGFibGUgZXJyb3IsIF9XS0luc3BlY3RvckV4dGVuc2lvbiAqIF9O dWxsYWJsZSBleHRlbnNpb24pIHsKKyAgICAgICAgRVhQRUNUX05VTEwoZXJyb3IpOworICAgICAg ICBFWFBFQ1RfTk9UX05VTEwoZXh0ZW5zaW9uKTsKKyAgICAgICAgc2hhcmVkSW5zcGVjdG9yRXh0 ZW5zaW9uID0gZXh0ZW5zaW9uOworCisgICAgICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9 IHRydWU7CisgICAgfV07CisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZwZW5kaW5nQ2Fs bGJhY2tXYXNDYWxsZWQpOworCisgICAgYXV0byBleHRlbnNpb25EZWxlZ2F0ZSA9IGFkb3B0TlMo W0luc3BlY3RvckV4dGVuc2lvbkRlbGVnYXRlRm9yVGVzdGluZ0luc3BlY3RvckV4dGVuc2lvbiBu ZXddKTsKKyAgICBbc2hhcmVkSW5zcGVjdG9yRXh0ZW5zaW9uIHNldERlbGVnYXRlOmV4dGVuc2lv bkRlbGVnYXRlLmdldCgpXTsKKworICAgIC8vIENyZWF0ZSBhbmQgc2hvdyBhbiBleHRlbnNpb24g dGFiLgorICAgIGF1dG8gaWNvblVSTCA9IFtOU1VSTCBVUkxXaXRoU3RyaW5nOkAidGVzdC1yZXNv dXJjZTovL1NlY29uZEV4dGVuc2lvbi9JbnNwZWN0b3JFeHRlbnNpb24tVGFiSWNvbi0zMHgzMC5w bmciXTsKKyAgICBhdXRvIHNvdXJjZVVSTCA9IFtOU1VSTCBVUkxXaXRoU3RyaW5nOkAidGVzdC1y ZXNvdXJjZTovL1NlY29uZEV4dGVuc2lvbi9JbnNwZWN0b3JFeHRlbnNpb24tYmFzaWMtdGFiLmh0 bWwiXTsKKworICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IGZhbHNlOworICAgIFtzaGFy ZWRJbnNwZWN0b3JFeHRlbnNpb24gY3JlYXRlVGFiV2l0aE5hbWU6QCJTZWNvbmRFeHRlbnNpb24t VGFiIiB0YWJJY29uVVJMOmljb25VUkwgc291cmNlVVJMOnNvdXJjZVVSTCBjb21wbGV0aW9uSGFu ZGxlcjpeKE5TRXJyb3IgKiBfTnVsbGFibGUgZXJyb3IsIE5TU3RyaW5nICogX051bGxhYmxlIGV4 dGVuc2lvblRhYklkZW50aWZpZXIpIHsKKyAgICAgICAgRVhQRUNUX05VTEwoZXJyb3IpOworICAg ICAgICBFWFBFQ1RfTk9UX05VTEwoZXh0ZW5zaW9uVGFiSWRlbnRpZmllcik7CisgICAgICAgIHNo YXJlZEV4dGVuc2lvblRhYklkZW50aWZpZXIgPSBleHRlbnNpb25UYWJJZGVudGlmaWVyOworCisg ICAgICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IHRydWU7CisgICAgfV07CisgICAgVGVz dFdlYktpdEFQSTo6VXRpbDo6cnVuKCZwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQpOworCisgICAg cGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gZmFsc2U7CisgICAgZGlkU2hvd0V4dGVuc2lvblRh Yldhc0NhbGxlZCA9IGZhbHNlOworICAgIFtbd2ViVmlldyBfaW5zcGVjdG9yXSBzaG93RXh0ZW5z aW9uVGFiV2l0aElkZW50aWZpZXI6c2hhcmVkRXh0ZW5zaW9uVGFiSWRlbnRpZmllci5nZXQoKSBj b21wbGV0aW9uSGFuZGxlcjpeKE5TRXJyb3IgKiBfTnVsbGFibGUgZXJyb3IpIHsKKyAgICAgICAg RVhQRUNUX05VTEwoZXJyb3IpOworCisgICAgICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9 IHRydWU7CisgICAgfV07CisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZwZW5kaW5nQ2Fs bGJhY2tXYXNDYWxsZWQpOworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmZGlkU2hvd0V4 dGVuc2lvblRhYldhc0NhbGxlZCk7CisKKyAgICBhdXRvIHNjcmlwdFNvdXJjZSA9IEAiISF3aW5k b3cuZ2V0VW5pcXVlVmFsdWUgJiYgd2luZG93LmdldFVuaXF1ZVZhbHVlKCkiOworCisgICAgLy8g UmVhZCBiYWNrIGEgdmFsdWUgdGhhdCBpcyB1bmlxdWUgdG8gdGhlIDxpZnJhbWU+J3Mgc2NyaXB0 IGNvbnRleHQuCisgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gZmFsc2U7CisgICAgW3No YXJlZEluc3BlY3RvckV4dGVuc2lvbiBfZXZhbHVhdGVTY3JpcHQ6c2NyaXB0U291cmNlIGluRXh0 ZW5zaW9uVGFiV2l0aElkZW50aWZpZXI6c2hhcmVkRXh0ZW5zaW9uVGFiSWRlbnRpZmllci5nZXQo KSBjb21wbGV0aW9uSGFuZGxlcjpeKE5TRXJyb3IgKiBfTnVsbGFibGUgZXJyb3IsIE5TRGljdGlv bmFyeSAqIF9OdWxsYWJsZSByZXN1bHQpIHsKKyAgICAgICAgRVhQRUNUX05VTEwoZXJyb3IpOwor ICAgICAgICBFWFBFQ1RfTk9UX05VTEwocmVzdWx0KTsKKyAgICAgICAgZXZhbHVhdGlvblJlc3Vs dCA9IHJlc3VsdDsKKworICAgICAgICBwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSB0cnVlOwor ICAgIH1dOworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmcGVuZGluZ0NhbGxiYWNrV2Fz Q2FsbGVkKTsKKworICAgIC8vIENhdXNlIHRoZSBleHRlbnNpb24gdGFiIHRvIGJlIGhpZGRlbi4g SXRzIDxpZnJhbWU+IHNob3VsZCBub3QgZGV0YWNoIGZyb20gdGhlIERPTS4KKyAgICBbW3dlYlZp ZXcgX2luc3BlY3Rvcl0gc2hvd0NvbnNvbGVdOworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1 bigmZGlkSGlkZUV4dGVuc2lvblRhYldhc0NhbGxlZCk7CisKKyAgICAvLyBDaGVjayB0aGUgdW5p cXVlIHZhbHVlIGFnYWluLCB3aGlsZSB0aGUgPGlmcmFtZT4gaXMgYmVpbmcgaGlkZGVuLiBJZiB0 aGUgPGlmcmFtZT4gaXMKKyAgICAvLyBkZXRhY2hlZCBmcm9tIHRoZSBET00sIHRoZW4gdGhpcyBl dmFsdWF0aW9uIHdpbGwgZmFpbCBvciBoYW5nLgorICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxl ZCA9IGZhbHNlOworICAgIFtzaGFyZWRJbnNwZWN0b3JFeHRlbnNpb24gX2V2YWx1YXRlU2NyaXB0 OnNjcmlwdFNvdXJjZSBpbkV4dGVuc2lvblRhYldpdGhJZGVudGlmaWVyOnNoYXJlZEV4dGVuc2lv blRhYklkZW50aWZpZXIuZ2V0KCkgY29tcGxldGlvbkhhbmRsZXI6XihOU0Vycm9yICogX051bGxh YmxlIGVycm9yLCBOU0RpY3Rpb25hcnkgKiBfTnVsbGFibGUgcmVzdWx0KSB7CisgICAgICAgIEVY UEVDVF9OVUxMKGVycm9yKTsKKyAgICAgICAgRVhQRUNUX05PVF9OVUxMKHJlc3VsdCk7CisgICAg ICAgIEVYUEVDVF9OU19FUVVBTChyZXN1bHQsIGV2YWx1YXRpb25SZXN1bHQuZ2V0KCkpOworCisg ICAgICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IHRydWU7CisgICAgfV07CisgICAgVGVz dFdlYktpdEFQSTo6VXRpbDo6cnVuKCZwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQpOworCisgICAg Ly8gUmVzZWxlY3QgdGhlIGV4dGVuc2lvbiB0YWIuCisgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2Fs bGVkID0gZmFsc2U7CisgICAgZGlkU2hvd0V4dGVuc2lvblRhYldhc0NhbGxlZCA9IGZhbHNlOwor ICAgIFtbd2ViVmlldyBfaW5zcGVjdG9yXSBzaG93RXh0ZW5zaW9uVGFiV2l0aElkZW50aWZpZXI6 c2hhcmVkRXh0ZW5zaW9uVGFiSWRlbnRpZmllci5nZXQoKSBjb21wbGV0aW9uSGFuZGxlcjpeKE5T RXJyb3IgKiBfTnVsbGFibGUgZXJyb3IpIHsKKyAgICAgICAgRVhQRUNUX05VTEwoZXJyb3IpOwor CisgICAgICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IHRydWU7CisgICAgfV07CisgICAg VGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQpOworICAg IFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmZGlkU2hvd0V4dGVuc2lvblRhYldhc0NhbGxlZCk7 CisKKyAgICAvLyBDaGVjayB0aGUgdW5pcXVlIHZhbHVlIGFnYWluIGFmdGVyIHJlc2VsZWN0aW5n IHRoZSBleHRlbnNpb24gdGFiLgorICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IGZhbHNl OworICAgIFtzaGFyZWRJbnNwZWN0b3JFeHRlbnNpb24gX2V2YWx1YXRlU2NyaXB0OnNjcmlwdFNv dXJjZSBpbkV4dGVuc2lvblRhYldpdGhJZGVudGlmaWVyOnNoYXJlZEV4dGVuc2lvblRhYklkZW50 aWZpZXIuZ2V0KCkgY29tcGxldGlvbkhhbmRsZXI6XihOU0Vycm9yICogX051bGxhYmxlIGVycm9y LCBOU0RpY3Rpb25hcnkgKiBfTnVsbGFibGUgcmVzdWx0KSB7CisgICAgICAgIEVYUEVDVF9OVUxM KGVycm9yKTsKKyAgICAgICAgRVhQRUNUX05PVF9OVUxMKHJlc3VsdCk7CisgICAgICAgIEVYUEVD VF9OU19FUVVBTChyZXN1bHQsIGV2YWx1YXRpb25SZXN1bHQuZ2V0KCkpOworCisgICAgICAgIHBl bmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IHRydWU7CisgICAgfV07CisgICAgVGVzdFdlYktpdEFQ STo6VXRpbDo6cnVuKCZwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQpOworCisgICAgLy8gVW5yZWdp c3RlciB0aGUgdGVzdCBleHRlbnNpb24uCisgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0g ZmFsc2U7CisgICAgW1t3ZWJWaWV3IF9pbnNwZWN0b3JdIHVucmVnaXN0ZXJFeHRlbnNpb246c2hh cmVkSW5zcGVjdG9yRXh0ZW5zaW9uLmdldCgpIGNvbXBsZXRpb25IYW5kbGVyOl4oTlNFcnJvciAq IF9OdWxsYWJsZSBlcnJvcikgeworICAgICAgICBFWFBFQ1RfTlVMTChlcnJvcik7CisKKyAgICAg ICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gdHJ1ZTsKKyAgICB9XTsKKyAgICBUZXN0V2Vi S2l0QVBJOjpVdGlsOjpydW4oJnBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCk7Cit9CisKICNlbmRp ZiAvLyBFTkFCTEUoSU5TUEVDVE9SX0VYVEVOU0lPTlMpCg== 440080 2021-10-04 11:20:38 -0700 2021-10-05 13:25:11 -0700 Patch v1.1 bug-230758-20211004112037.patch text/plain 19390 bburg U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzNDk4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkluc3BlY3RvclVJL0NoYW5nZUxvZwppbmRleCAy ZTZjYzU2NzA0M2VmNzk1MzRlOGYyNmVjNWI5ZDg3MDViNzA5MDI3Li43MDZiODNjODE0YWVjODY4 ZDNmYmZkNjhhZmNiZjg2ZDdhYzc0NDlmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9y VUkvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKQEAgLTEs MyArMSw0NCBAQAorMjAyMS0wOS0zMCAgQkogQnVyZyAgPGJidXJnQGFwcGxlLmNvbT4KKworICAg ICAgICBXZWIgSW5zcGVjdG9yOiBXZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50VmlldyBz aG91bGQgbm90IHJlbG9hZCBpdHMgaWZyYW1lIHdoZW4gZGV0YWNoZWQKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzMDc1OAorICAgICAgICA8cmRhcjov Lzc0NzE0ODYxPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIFdoZW4gYW4gPGlmcmFtZT4gZWxlbWVudCBkZXRhY2hlcyBmcm9tIHRoZSBET00sIHRoZSBz Y3JpcHQgY29udGV4dCBpcyBkZXN0cm95ZWQsIHdoaWNoIHdlIGRvbid0CisgICAgICAgIHdhbnQg dG8gaGFwcGVuIGZvciBfV0tJbnNwZWN0b3JFeHRlbnNpb24gdGFicy4gRml4IHRoaXMgYnkgdGVh Y2hpbmcgQ29udGVudFZpZXdDb250YWluZXIgdG8KKyAgICAgICAgJ2hpZGUnIHN1Y2ggY29udGVu dCB2aWV3cyBieSBzZXR0aW5nIGBkaXNwbGF5Om5vbmVgIHJhdGhlciB0aGFuIGRldGFjaGluZyBm cm9tIHRoZSBET00uCisKKyAgICAgICAgKiBVc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3 Q29udGFpbmVyLmpzOgorICAgICAgICAoV0kuQ29udGVudFZpZXdDb250YWluZXIucHJvdG90eXBl Ll9zaG93RW50cnkpOgorICAgICAgICAoV0kuQ29udGVudFZpZXdDb250YWluZXIucHJvdG90eXBl Ll9oaWRlRW50cnkpOgorICAgICAgICBTZXQgYW5kIHVuc2V0ICdkaXNwbGF5Om5vbmUnIGluc3Rl YWQgb2YgY2FsbGluZyBhZGRTdWJ2aWV3KCkgLyByZW1vdmVTdWJ2aWV3KCkuCisKKyAgICAgICAg KiBVc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmNzczoKKyAgICAgICAg KC5jb250ZW50LXZpZXctY29udGFpbmVyID4gLmNvbnRlbnQtdmlldy5oaWRkZW4tZm9yLWRldGFj aCk6IEFkZGVkLgorCisgICAgICAgIChXSS5Db250ZW50Vmlld0NvbnRhaW5lci5wcm90b3R5cGUu X2Rpc2Fzc29jaWF0ZUZyb21Db250ZW50Vmlldyk6CisgICAgICAgIENsZWFuIHVwIGFueSByZW1h aW5pbmcgY29udGVudCB2aWV3cyB0aGF0IHdlcmUgbm90IGRldGFjaGVkIGR1ZSB0byBvdmVycmlk aW5nIHNob3VsZE5vdFJlbW92ZUZyb21ET01XaGVuSGlkZGVuLgorCisgICAgICAgICogVXNlcklu dGVyZmFjZS9WaWV3cy9Db250ZW50Vmlldy5qczoKKyAgICAgICAgKFdJLkNvbnRlbnRWaWV3LnBy b3RvdHlwZS5nZXQgc2hvdWxkTm90UmVtb3ZlRnJvbURPTVdoZW5IaWRkZW4pOiBBZGRlZC4KKwor ICAgICAgICAqIFVzZXJJbnRlcmZhY2UvVmlld3MvV2ViSW5zcGVjdG9yRXh0ZW5zaW9uVGFiQ29u dGVudFZpZXcuanM6CisgICAgICAgIChXSS5XZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50 Vmlldyk6CisgICAgICAgIChXSS5XZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50Vmlldy5w cm90b3R5cGUuZ2V0IHNob3VsZE5vdFJlbW92ZUZyb21ET01XaGVuSGlkZGVuKToKKyAgICAgICAg T3ZlcnJpZGUgdGhpcyB0byBvcHQgaW50byB0aGUgYWx0ZXJuYXRlIGJlaGF2aW9yIHRoYXQgZG9l cyBub3QgZGV0YWNoIGZyb20gdGhlIERPTS4gSXQgaXMgc3RpbGwKKyAgICAgICAgbmVjZXNzYXJ5 IHRvIGNhbGwgYXR0YWNoZWQoKSBhbmQgZGV0YWNoZWQoKSBzbyB0aGF0IFdlYklucGVjdG9yRXh0 ZW5zaW9uVGFiQ29udGVudFZpZXcgY2FuIGdlbmVyYXRlCisgICAgICAgIGRpZFNob3dFeHRlbnNp b25UYWIvZGlkSGlkZUV4dGVuc2lvblRhYiBldmVudCBjYWxsYmFja3MuCisKKyAgICAgICAgKiBV c2VySW50ZXJmYWNlL0NvbnRyb2xsZXJzL1dlYkluc3BlY3RvckV4dGVuc2lvbkNvbnRyb2xsZXIu anM6CisgICAgICAgIChXSS5XZWJJbnNwZWN0b3JFeHRlbnNpb25Db250cm9sbGVyLnByb3RvdHlw ZS5nZXQgcmVnaXN0ZXJlZEV4dGVuc2lvbnMpOgorICAgICAgICAqIFVzZXJJbnRlcmZhY2UvRGVi dWcvQm9vdHN0cmFwLmpzOgorICAgICAgICAodXBkYXRlTW9ja1dlYkV4dGVuc2lvblRhYik6Cisg ICAgICAgIChXSS5ydW5Cb290c3RyYXBPcGVyYXRpb25zKToKKyAgICAgICAgVGhpcyBpcyBhIGRy aXZlLWJ5IGZpeCB0byBhZGRyZXNzIGEgY29uc29sZSBhc3NlcnRpb24gc2VlbiB3aGlsZSBkZXZl bG9waW5nIHRoZSBBUEkgdGVzdC4KKyAgICAgICAgRG9uJ3QgdW5yZWdpc3RlciB0aGUgbW9jayBl eHRlbnNpb24gaWYgaXQgaXMgbm90IHJlZ2lzdGVyZWQgaW4gdGhlIGZpcnN0IHBsYWNlLgorCiAy MDIxLTA5LTI5ICBCSiBCdXJnICA8YmJ1cmdAYXBwbGUuY29tPgogCiAgICAgICAgIFtDb2NvYV0g YWRkIF9XS0luc3BlY3RvckV4dGVuc2lvbiBTUEkgdG8gZXZhbHVhdGUgc2NyaXB0IG9uIGFuIGV4 dGVuc2lvbiB0YWIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJm YWNlL0NvbnRyb2xsZXJzL1dlYkluc3BlY3RvckV4dGVuc2lvbkNvbnRyb2xsZXIuanMgYi9Tb3Vy Y2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9Db250cm9sbGVycy9XZWJJbnNwZWN0b3JF eHRlbnNpb25Db250cm9sbGVyLmpzCmluZGV4IDU3NWI0MDgyN2M1MTdkMmFhZTc1NjY5ZDAyNWUy OTliODk3YzU4ZjAuLjM4YTM3OWM0ZDhhZTgxYjVmY2YwNmZlYTcyMmFiYzY4YWVjNzhiOGMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL0NvbnRyb2xsZXJz L1dlYkluc3BlY3RvckV4dGVuc2lvbkNvbnRyb2xsZXIuanMKKysrIGIvU291cmNlL1dlYkluc3Bl Y3RvclVJL1VzZXJJbnRlcmZhY2UvQ29udHJvbGxlcnMvV2ViSW5zcGVjdG9yRXh0ZW5zaW9uQ29u dHJvbGxlci5qcwpAQCAtMzcsNiArMzcsMTEgQEAgV0kuV2ViSW5zcGVjdG9yRXh0ZW5zaW9uQ29u dHJvbGxlciA9IGNsYXNzIFdlYkluc3BlY3RvckV4dGVuc2lvbkNvbnRyb2xsZXIgZXh0ZW4KIAog ICAgIC8vIFB1YmxpYwogCisgICAgZ2V0IHJlZ2lzdGVyZWRFeHRlbnNpb25zKCkKKyAgICB7Cisg ICAgICAgIHJldHVybiBuZXcgU2V0KHRoaXMuX2V4dGVuc2lvbkZvckV4dGVuc2lvbklETWFwLmtl eXMoKSk7CisgICAgfQorCiAgICAgcmVnaXN0ZXJFeHRlbnNpb24oZXh0ZW5zaW9uSUQsIGRpc3Bs YXlOYW1lKQogICAgIHsKICAgICAgICAgaWYgKHRoaXMuX2V4dGVuc2lvbkZvckV4dGVuc2lvbklE TWFwLmhhcyhleHRlbnNpb25JRCkpIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JV SS9Vc2VySW50ZXJmYWNlL0RlYnVnL0Jvb3RzdHJhcC5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JV SS9Vc2VySW50ZXJmYWNlL0RlYnVnL0Jvb3RzdHJhcC5qcwppbmRleCA4ZDQ0MDM2ZWJhM2NkZDVi MGFmNTYxOTI1NDJiZDFkNTc1NWM5NjE2Li5kODg4ZTIwNzRkOGRlN2I2MDEwYzc2YjM1ZjczODdh NGE2YzQ1NTZlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFj ZS9EZWJ1Zy9Cb290c3RyYXAuanMKKysrIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRl cmZhY2UvRGVidWcvQm9vdHN0cmFwLmpzCkBAIC0xNTAsNyArMTUwLDkgQEAgV0kucnVuQm9vdHN0 cmFwT3BlcmF0aW9ucyA9IGZ1bmN0aW9uKCkgewogCiAgICAgICAgIC8vIFNpbXVsYXRlcyB0aGUg c3RlcHMgdGFrZW4gYnkgV2ViSW5zcGVjdG9yVUlFeHRlbnNpb25Db250cm9sbGVyIHRvIGNyZWF0 ZSBhbiBleHRlbnNpb24gdGFiIGluIFdlYkluc3BlY3RvclVJLgogICAgICAgICBpZiAoIVdJLnNl dHRpbmdzLmVuZ2luZWVyaW5nU2hvd01vY2tXZWJFeHRlbnNpb25UYWIudmFsdWUpIHsKLSAgICAg ICAgICAgIEluc3BlY3RvckZyb250ZW5kQVBJLnVucmVnaXN0ZXJFeHRlbnNpb24obW9ja0RhdGEu ZXh0ZW5zaW9uSUQpOworICAgICAgICAgICAgaWYgKFdJLnNoYXJlZEFwcC5leHRlbnNpb25Db250 cm9sbGVyLnJlZ2lzdGVyZWRFeHRlbnNpb25zLmhhcyhtb2NrRGF0YS5leHRlbnNpb25JRCkpCisg ICAgICAgICAgICAgICAgSW5zcGVjdG9yRnJvbnRlbmRBUEkudW5yZWdpc3RlckV4dGVuc2lvbiht b2NrRGF0YS5leHRlbnNpb25JRCk7CisKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9D b250ZW50Vmlldy5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdz L0NvbnRlbnRWaWV3LmpzCmluZGV4IDA1MzlhNWZlNDQxMDQzZTM4NTA3MzdjMmVhMTUwNDRlYWFm YTdjOGQuLjIzNzhiOGIyNmRiMzI4M2M5NTgxNWVhZjc2M2M4MGQyMWU4OWVjYWQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3 LmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRl bnRWaWV3LmpzCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMywgMjAx NSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTMt MjAyMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMKQEAgLTQyLDYgKzQyLDEzIEBAIFdJLkNvbnRlbnRWaWV3ID0gY2xhc3MgQ29u dGVudFZpZXcgZXh0ZW5kcyBXSS5WaWV3CiAKICAgICAvLyBTdGF0aWMKIAorICAgIC8vIEltcGxl bWVudGVkIGJ5IHN1YmNsYXNzZXMuCisgICAgc3RhdGljIHNob3VsZE5vdFJlbW92ZUZyb21ET01X aGVuSGlkZGVuKCkKKyAgICB7CisgICAgICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgY29udGVu dCB2aWV3IHNob3VsZCAqbm90KiBiZSBkZXRhY2hlZCBmcm9tIHRoZSBET00gd2hlbiBoaWRkZW4u CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisKICAgICBzdGF0aWMgY3JlYXRlRnJvbVJl cHJlc2VudGVkT2JqZWN0KHJlcHJlc2VudGVkT2JqZWN0LCBleHRyYUFyZ3VtZW50cykKICAgICB7 CiAgICAgICAgIGNvbnNvbGUuYXNzZXJ0KHJlcHJlc2VudGVkT2JqZWN0KTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29u dGFpbmVyLmNzcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0Nv bnRlbnRWaWV3Q29udGFpbmVyLmNzcwppbmRleCAzYmVhYjFhOGM1NTAxOTNlOGIwNTY1MThlMDYy YWMyZDk1NjA0OGMxLi5hNDQ4YTE1YTA3NGMwM2IyZjIzZTc1ZDk2ZDRiZjA1ZmUyNzk2N2QzIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9Db250 ZW50Vmlld0NvbnRhaW5lci5jc3MKKysrIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRl cmZhY2UvVmlld3MvQ29udGVudFZpZXdDb250YWluZXIuY3NzCkBAIC0xLDUgKzEsNSBAQAogLyoK LSAqIENvcHlyaWdodCAoQykgMjAxMyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KiBDb3B5cmlnaHQgKEMpIDIwMTMtMjAyMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu CiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTM3LDMgKzM3LDcgQEAKIAogICAg IG92ZXJmbG93OiBoaWRkZW47CiB9CisKKy5jb250ZW50LXZpZXctY29udGFpbmVyID4gLmNvbnRl bnQtdmlldy5oaWRkZW4tc2ltdWxhdGluZy1kb20tZGV0YWNoZWQgeworICAgIGRpc3BsYXk6IG5v bmU7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9W aWV3cy9Db250ZW50Vmlld0NvbnRhaW5lci5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2Vy SW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmpzCmluZGV4IGFiMDU2ZWY5MzUy MTVhZDA5MDQzYTg3ZmM5NzYyMGJjN2U4NGYwNTAuLjIzMmQ1ZDZkOGNiMzliMTZkNWNmYzU3NDNh NWJhMjJlNThjNTA2YTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50 ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNw ZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmpzCkBAIC00 MjEsNiArNDIxLDExIEBAIFdJLkNvbnRlbnRWaWV3Q29udGFpbmVyID0gY2xhc3MgQ29udGVudFZp ZXdDb250YWluZXIgZXh0ZW5kcyBXSS5WaWV3CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAg IH0KIAorICAgICAgICAvLyBEZXNlbGVjdGVkIGV4dGVuc2lvbiB0YWJzIGFyZSBzdGlsbCBhdHRh Y2hlZCB0byB0aGUgRE9NIHZpYSBgdGhpcy5lbGVtZW50YCwKKyAgICAgICAgLy8gc28gdGhpcyBp cyB0aGUgbGFzdCBjaGFuY2UgdG8gYWN0dWFsbHkgcmVtb3ZlIHRoZSBzdWJ2aWV3IGFuZCBkZXRh Y2ggZnJvbSB0aGUgRE9NLgorICAgICAgICBpZiAoY29udGVudFZpZXcuY29uc3RydWN0b3Iuc2hv dWxkTm90UmVtb3ZlRnJvbURPTVdoZW5IaWRkZW4oKSAmJiBjb250ZW50Vmlldy5pc0F0dGFjaGVk KQorICAgICAgICAgICAgdGhpcy5yZW1vdmVTdWJ2aWV3KGNvbnRlbnRWaWV3KTsKKwogICAgICAg ICBjb25zb2xlLmFzc2VydCghY29udGVudFZpZXcuaXNBdHRhY2hlZCk7CiAKICAgICAgICAgaWYg KCFjb250ZW50Vmlldy5fcGFyZW50Q29udGFpbmVyKQpAQCAtNDU3LDYgKzQ2MiwxMCBAQCBXSS5D b250ZW50Vmlld0NvbnRhaW5lciA9IGNsYXNzIENvbnRlbnRWaWV3Q29udGFpbmVyIGV4dGVuZHMg V0kuVmlldwogCiAgICAgICAgIGlmICghdGhpcy5zdWJ2aWV3cy5pbmNsdWRlcyhlbnRyeS5jb250 ZW50VmlldykpCiAgICAgICAgICAgICB0aGlzLmFkZFN1YnZpZXcoZW50cnkuY29udGVudFZpZXcp OworICAgICAgICBlbHNlIGlmIChlbnRyeS5jb250ZW50Vmlldy5jb25zdHJ1Y3Rvci5zaG91bGRO b3RSZW1vdmVGcm9tRE9NV2hlbkhpZGRlbigpKSB7CisgICAgICAgICAgICBlbnRyeS5jb250ZW50 Vmlldy5lbGVtZW50LmNsYXNzTGlzdC5yZW1vdmUoImhpZGRlbi1zaW11bGF0aW5nLWRvbS1kZXRh Y2hlZCIpOworICAgICAgICAgICAgZW50cnkuY29udGVudFZpZXcuYXR0YWNoZWQoKTsKKyAgICAg ICAgfQogCiAgICAgICAgIGVudHJ5LnByZXBhcmVUb1Nob3coKTsKICAgICB9CkBAIC00NzEsOCAr NDgwLDEzIEBAIFdJLkNvbnRlbnRWaWV3Q29udGFpbmVyID0gY2xhc3MgQ29udGVudFZpZXdDb250 YWluZXIgZXh0ZW5kcyBXSS5WaWV3CiAgICAgICAgICAgICByZXR1cm47CiAKICAgICAgICAgZW50 cnkucHJlcGFyZVRvSGlkZSgpOwotICAgICAgICBpZiAodGhpcy5zdWJ2aWV3cy5pbmNsdWRlcyhl bnRyeS5jb250ZW50VmlldykpCi0gICAgICAgICAgICB0aGlzLnJlbW92ZVN1YnZpZXcoZW50cnku Y29udGVudFZpZXcpOworICAgICAgICBpZiAodGhpcy5zdWJ2aWV3cy5pbmNsdWRlcyhlbnRyeS5j b250ZW50VmlldykpIHsKKyAgICAgICAgICAgIGlmIChlbnRyeS5jb250ZW50Vmlldy5jb25zdHJ1 Y3Rvci5zaG91bGROb3RSZW1vdmVGcm9tRE9NV2hlbkhpZGRlbigpKSB7CisgICAgICAgICAgICAg ICAgZW50cnkuY29udGVudFZpZXcuZWxlbWVudC5jbGFzc0xpc3QuYWRkKCJoaWRkZW4tc2ltdWxh dGluZy1kb20tZGV0YWNoZWQiKTsKKyAgICAgICAgICAgICAgICBlbnRyeS5jb250ZW50Vmlldy5k ZXRhY2hlZCgpOworICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAgdGhpcy5yZW1v dmVTdWJ2aWV3KGVudHJ5LmNvbnRlbnRWaWV3KTsKKyAgICAgICAgfQogICAgIH0KIAogICAgIF90 b21ic3RvbmVDb250ZW50Vmlld0NvbnRhaW5lcnNGb3JDb250ZW50Vmlldyhjb250ZW50VmlldykK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL1Rh YkJyb3dzZXIuanMgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9U YWJCcm93c2VyLmpzCmluZGV4IGFlYTI1MmIxNmZjMmIxZDllNTVmNDFjZDMzODY3NWI3MjQwOWZj NWEuLjgwNGQzYmJmMTNhMzcxODljM2JjMjQ1MjUxMTlkYmMwMWY5MDQ0MTIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL1RhYkJyb3dzZXIuanMK KysrIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvVmlld3MvVGFiQnJvd3Nl ci5qcwpAQCAtMTcxLDcgKzE3MSw5IEBAIFdJLlRhYkJyb3dzZXIgPSBjbGFzcyBUYWJCcm93c2Vy IGV4dGVuZHMgV0kuVmlldwogICAgICAgICAgICAgdGhpcy5fdGFiQmFyLmFkZFRhYkJhckl0ZW0o dGFiQmFySXRlbSwgb3B0aW9ucyk7CiAKICAgICAgICAgY29uc29sZS5hc3NlcnQodGhpcy5fcmVj ZW50VGFiQ29udGVudFZpZXdzLmxlbmd0aCA9PT0gdGhpcy5fdGFiQmFyLnRhYkNvdW50KTsKLSAg ICAgICAgY29uc29sZS5hc3NlcnQoIXRoaXMuc2VsZWN0ZWRUYWJDb250ZW50VmlldyB8fCB0aGlz LnNlbGVjdGVkVGFiQ29udGVudFZpZXcgPT09IHRoaXMuX3JlY2VudFRhYkNvbnRlbnRWaWV3c1sw XSk7CisKKyAgICAgICAgbGV0IHNob3VsZFNhdmVUYWIgPSB0aGlzLnNlbGVjdGVkVGFiQ29udGVu dFZpZXc/LmNvbnN0cnVjdG9yLnNob3VsZFNhdmVUYWIoKSB8fCB0aGlzLnNlbGVjdGVkVGFiQ29u dGVudFZpZXc/LmNvbnN0cnVjdG9yLnNob3VsZFBpblRhYigpOworICAgICAgICBjb25zb2xlLmFz c2VydCghdGhpcy5zZWxlY3RlZFRhYkNvbnRlbnRWaWV3IHx8IHRoaXMuc2VsZWN0ZWRUYWJDb250 ZW50VmlldyA9PT0gdGhpcy5fcmVjZW50VGFiQ29udGVudFZpZXdzWzBdIHx8ICFzaG91bGRTYXZl VGFiKTsKIAogICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9XZWJJbnNwZWN0b3JFeHRlbnNpb25U YWJDb250ZW50Vmlldy5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1Zp ZXdzL1dlYkluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3LmpzCmluZGV4IDc0YWZhNGNj ZmJkMjhjZjYzNGIxODczNDhkMDY1NzBiNmViZTIwYWUuLjFiYjRhNDBmYWIzNGU4YjVlYWRjOWRl ZWU0MDc2YzU5Y2RjNWE4NDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2Vy SW50ZXJmYWNlL1ZpZXdzL1dlYkluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3LmpzCisr KyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL1dlYkluc3BlY3Rv ckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3LmpzCkBAIC00MCw5ICs0MCw2IEBAIFdJLldlYkluc3Bl Y3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3ID0gY2xhc3MgV2ViSW5zcGVjdG9yRXh0ZW5zaW9u VGFiQ29udGVudFZpCiAgICAgICAgIHRoaXMuX3RhYkluZm8gPSB0YWJJbmZvOwogICAgICAgICB0 aGlzLl9zb3VyY2VVUkwgPSBzb3VyY2VVUkw7CiAKLSAgICAgICAgLy8gRklYTUU6IHRoZSA8aWZy YW1lPidzIGRvY3VtZW50IGlzIGltcGxpY2l0bHkgcmVsb2FkZWQgd2hlbiB0aGlzCi0gICAgICAg IC8vIGNvbnRlbnQgdmlldydzIGVsZW1lbnQgaXMgZGV0YWNoZWQgYW5kIGxhdGVyIHJlLWF0dGFj aGVkIHRvIHRoZSBET00uCi0gICAgICAgIC8vIFRoaXMgaXMgYSBidWcgYW5kIHdpbGwgYmUgYWRk cmVzc2VkIGluIDxodHRwczovL3dlYmtpdC5vcmcvYi8yMzA3NTg+LgogICAgICAgICB0aGlzLl9p ZnJhbWVFbGVtZW50ID0gdGhpcy5lbGVtZW50LmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZUVs ZW1lbnQoImlmcmFtZSIpKTsKICAgICAgICAgdGhpcy5faWZyYW1lRWxlbWVudC5hZGRFdmVudExp c3RlbmVyKCJsb2FkIiwgdGhpcy5fZXh0ZW5zaW9uRnJhbWVEaWRMb2FkLmJpbmQodGhpcykpOwog ICAgICAgICB0aGlzLl9pZnJhbWVFbGVtZW50LnNyYyA9IHRoaXMuX3NvdXJjZVVSTDsKQEAgLTY1 LDYgKzYyLDExIEBAIFdJLldlYkluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3ID0gY2xh c3MgV2ViSW5zcGVjdG9yRXh0ZW5zaW9uVGFiQ29udGVudFZpCiAgICAgICAgIHJldHVybiB0cnVl OwogICAgIH0KIAorICAgIC8vIFRoaXMgaXMgbmVjZXNzYXJ5IHRvIGF2b2lkIHRoZSA8aWZyYW1l PiBjb250ZW50IGZyb20gYmVpbmcgcmVsb2FkZWQgd2hlbiB0aGUgZXh0ZW5zaW9uIHRhYiBpcyBo aWRkZW4uCisgICAgc3RhdGljIHNob3VsZE5vdFJlbW92ZUZyb21ET01XaGVuSGlkZGVuKCkgeyBy ZXR1cm4gdHJ1ZTsgfQorCisgICAgLy8gUHJvdGVjdGVkCisKICAgICBhdHRhY2hlZCgpCiAgICAg ewogICAgICAgICBzdXBlci5hdHRhY2hlZCgpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9n IGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGNjNTQ4NTM5YTFjMGQ4ZmYwMmEzMDBhYzA4OWRiYTM1 NDk1ZmU5NDYuLjU4OTAyZGU4ODVmNDUzNWNlOTViNTI1ZGU5MWIxNmUzOTc0MDdiYWIgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx NyBAQAorMjAyMS0wOS0zMCAgQkogQnVyZyAgPGJidXJnQGFwcGxlLmNvbT4KKworICAgICAgICBX ZWIgSW5zcGVjdG9yOiBXZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50VmlldyBzaG91bGQg bm90IHJlbG9hZCBpdHMgaWZyYW1lIHdoZW4gZGV0YWNoZWQKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzMDc1OAorICAgICAgICA8cmRhcjovLzc0NzE0 ODYxPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCBhIG5ldyB0ZXN0IHRvIHZlcmlmeSB0aGF0IHJlLXNlbGVjdGluZyBhbiBleHRlbnNpb24gdGFi IGRvZXMgbm90IGNhdXNlIGl0IHRvIHJlbG9hZC4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkv VGVzdHMvV2ViS2l0Q29jb2EvSW5zcGVjdG9yRXh0ZW5zaW9uLWJhc2ljLXRhYi5odG1sOgorICAg ICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvV0tJbnNwZWN0b3JFeHRlbnNp b24ubW06CisgICAgICAgIChURVNUKToKKwogMjAyMS0xMC0wNCAgQWFrYXNoIEphaW4gIDxhYWth c2hfamFpbkBhcHBsZS5jb20+CiAKICAgICAgICAgU2VuZCBFV1MgZXhjZXB0aW9uIGVtYWlscyB0 byBib3Qgd2F0Y2hlcnMgaW5zdGVhZCBvZiBBYWthc2gKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvSW5zcGVjdG9yRXh0ZW5zaW9uLWJhc2ljLXRhYi5o dG1sIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9JbnNwZWN0b3JFeHRl bnNpb24tYmFzaWMtdGFiLmh0bWwKaW5kZXggNDJiZjE5ZDBiMjc3NTQyMTljNTIyZDdhM2FkMDhh MjljNGE1YTBlNC4uNmZhYTlmYjQwZjYwNTE0ZmVmYzNlYWU0YzEzZWNmN2ZiNGMyYjFmMCAxMDA2 NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9JbnNwZWN0b3JF eHRlbnNpb24tYmFzaWMtdGFiLmh0bWwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9X ZWJLaXRDb2NvYS9JbnNwZWN0b3JFeHRlbnNpb24tYmFzaWMtdGFiLmh0bWwKQEAgLTEsMTAgKzEs MjQgQEAKIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0PgorICAgIC8vIFVzZWQgYnkgV0tJbnNwZWN0 b3JFeHRlbnNpb24uQ2FuRXZhbHVhdGVTY3JpcHRJbkV4dGVuc2lvblRhYgogICAgIHdpbmRvdy5f c2VjcmV0VmFsdWUgPSB7YW5zd2VyOjQyfTsKKworICAgIC8vIFVzZWQgYnkgV0tJbnNwZWN0b3JF eHRlbnNpb24uRXh0ZW5zaW9uVGFiSXNQZXJzaXN0ZW50CisgICAgd2luZG93LmdldFVuaXF1ZVZh bHVlID0gZnVuY3Rpb24oKSB7CisgICAgICAgIGlmICghd2luZG93Ll9jYWNoZWRVbmlxdWVWYWx1 ZSkgeworICAgICAgICAgICAgd2luZG93Ll9jYWNoZWRVbmlxdWVWYWx1ZSA9IE1hdGguZmxvb3Io TWF0aC5yYW5kb20oKSAqIDEwZTkpOworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInVuaXF1ZVZhbHVlRmllbGQiKS5pbm5lclRleHQgPSB3aW5kb3cuX2NhY2hlZFVuaXF1ZVZh bHVlOworICAgICAgICB9CisKKyAgICAgICAgcmV0dXJuIHdpbmRvdy5fY2FjaGVkVW5pcXVlVmFs dWU7CisgICAgfQogPC9zY3JpcHQ+CiA8Ym9keT4KIDxoMT5UaGlzIGlzIGEgdGVzdCBleHRlbnNp b24uPC9oMT4KIDxwPkluIGEgbm9ybWFsIGV4dGVuc2lvbiwgdGhpcyBhcmVhIHdvdWxkIHNob3cg dGhlIGV4dGVuc2lvbidzIHVzZXIgaW50ZXJmYWNlLjwvcD4KKzxwPlRoZSB1bmlxdWUgdmFsdWUg Zm9yIHRoaXMgaWZyYW1lJ3MgZXhlY3V0aW9uIGNvbnRleHQgaXM6CisgICAgPHNwYW4gaWQ9InVu aXF1ZVZhbHVlRmllbGQiPlRCRDwvc3Bhbj4KKzwvcD4KIDwvYm9keT4KIDwvaHRtbD4KZGlmZiAt LWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvV0tJbnNwZWN0b3JF eHRlbnNpb24ubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1dLSW5z cGVjdG9yRXh0ZW5zaW9uLm1tCmluZGV4IDI0MjE3Mjg4YzljZmMxMGY5NzViYzc3OGIxODQ1MjYw NzA0ZTkzOWYuLmE2NDA0NDNmNGViMzkxYmUzYjBjMTRmNGY0MmExYmI1ODQzZWEzMWEgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvV0tJbnNwZWN0b3JF eHRlbnNpb24ubW0KKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9X S0luc3BlY3RvckV4dGVuc2lvbi5tbQpAQCAtNDcsNiArNDcsNyBAQCBzdGF0aWMgYm9vbCBwZW5k aW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSBmYWxzZTsKIHN0YXRpYyBSZXRhaW5QdHI8VGVzdEluc3Bl Y3RvclVSTFNjaGVtZUhhbmRsZXI+IHNoYXJlZFVSTFNjaGVtZUhhbmRsZXI7CiBzdGF0aWMgUmV0 YWluUHRyPF9XS0luc3BlY3RvckV4dGVuc2lvbj4gc2hhcmVkSW5zcGVjdG9yRXh0ZW5zaW9uOwog c3RhdGljIFJldGFpblB0cjxOU1N0cmluZz4gc2hhcmVkRXh0ZW5zaW9uVGFiSWRlbnRpZmllcjsK K3N0YXRpYyBSZXRhaW5QdHI8TlNPYmplY3Q+IGV2YWx1YXRpb25SZXN1bHQ7CiAKIHN0YXRpYyB2 b2lkIHJlc2V0R2xvYmFsU3RhdGUoKQogewpAQCAtMTg4LDQgKzE4OSwxMjEgQEAgVEVTVChXS0lu c3BlY3RvckV4dGVuc2lvbiwgQ2FuRXZhbHVhdGVTY3JpcHRJbkV4dGVuc2lvblRhYikKICAgICBU ZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJnBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCk7CiB9CiAK K1RFU1QoV0tJbnNwZWN0b3JFeHRlbnNpb24sIEV4dGVuc2lvblRhYklzUGVyc2lzdGVudCkKK3sK KyAgICByZXNldEdsb2JhbFN0YXRlKCk7CisKKyAgICBhdXRvIHdlYlZpZXdDb25maWd1cmF0aW9u ID0gYWRvcHROUyhbV0tXZWJWaWV3Q29uZmlndXJhdGlvbiBuZXddKTsKKyAgICB3ZWJWaWV3Q29u ZmlndXJhdGlvbi5nZXQoKS5wcmVmZXJlbmNlcy5fZGV2ZWxvcGVyRXh0cmFzRW5hYmxlZCA9IFlF UzsKKyAgICBhdXRvIHdlYlZpZXcgPSBhZG9wdE5TKFtbV0tXZWJWaWV3IGFsbG9jXSBpbml0V2l0 aEZyYW1lOkNHUmVjdE1ha2UoMCwgMCwgODAwLCA2MDApIGNvbmZpZ3VyYXRpb246d2ViVmlld0Nv bmZpZ3VyYXRpb24uZ2V0KCldKTsKKyAgICBhdXRvIHVpRGVsZWdhdGUgPSBhZG9wdE5TKFtVSURl bGVnYXRlRm9yVGVzdGluZ0luc3BlY3RvckV4dGVuc2lvbiBuZXddKTsKKworICAgIFt3ZWJWaWV3 IHNldFVJRGVsZWdhdGU6dWlEZWxlZ2F0ZS5nZXQoKV07CisgICAgW3dlYlZpZXcgbG9hZEhUTUxT dHJpbmc6QCI8aGVhZD48dGl0bGU+VGVzdCBwYWdlIHRvIGJlIGluc3BlY3RlZDwvdGl0bGU+PC9o ZWFkPjxib2R5PjxwPkZpbGxlciBjb250ZW50PC9wPjwvYm9keT4iIGJhc2VVUkw6W05TVVJMIFVS TFdpdGhTdHJpbmc6QCJodHRwOi8vZXhhbXBsZS5jb20vIl1dOworCisgICAgW1t3ZWJWaWV3IF9p bnNwZWN0b3JdIHNob3ddOworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmZGlkQXR0YWNo TG9jYWxJbnNwZWN0b3JDYWxsZWQpOworCisgICAgYXV0byBleHRlbnNpb25JRCA9IFtOU1VVSUQg VVVJRF0uVVVJRFN0cmluZzsKKyAgICBhdXRvIGV4dGVuc2lvbkRpc3BsYXlOYW1lID0gQCJTZWNv bmRFeHRlbnNpb24iOworCisgICAgLy8gUmVnaXN0ZXIgdGhlIHRlc3QgZXh0ZW5zaW9uLgorICAg IHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IGZhbHNlOworICAgIFtbd2ViVmlldyBfaW5zcGVj dG9yXSByZWdpc3RlckV4dGVuc2lvbldpdGhJRDpleHRlbnNpb25JRCBkaXNwbGF5TmFtZTpleHRl bnNpb25EaXNwbGF5TmFtZSBjb21wbGV0aW9uSGFuZGxlcjpeKE5TRXJyb3IgKiBfTnVsbGFibGUg ZXJyb3IsIF9XS0luc3BlY3RvckV4dGVuc2lvbiAqIF9OdWxsYWJsZSBleHRlbnNpb24pIHsKKyAg ICAgICAgRVhQRUNUX05VTEwoZXJyb3IpOworICAgICAgICBFWFBFQ1RfTk9UX05VTEwoZXh0ZW5z aW9uKTsKKyAgICAgICAgc2hhcmVkSW5zcGVjdG9yRXh0ZW5zaW9uID0gZXh0ZW5zaW9uOworCisg ICAgICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IHRydWU7CisgICAgfV07CisgICAgVGVz dFdlYktpdEFQSTo6VXRpbDo6cnVuKCZwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQpOworCisgICAg YXV0byBleHRlbnNpb25EZWxlZ2F0ZSA9IGFkb3B0TlMoW0luc3BlY3RvckV4dGVuc2lvbkRlbGVn YXRlRm9yVGVzdGluZ0luc3BlY3RvckV4dGVuc2lvbiBuZXddKTsKKyAgICBbc2hhcmVkSW5zcGVj dG9yRXh0ZW5zaW9uIHNldERlbGVnYXRlOmV4dGVuc2lvbkRlbGVnYXRlLmdldCgpXTsKKworICAg IC8vIENyZWF0ZSBhbmQgc2hvdyBhbiBleHRlbnNpb24gdGFiLgorICAgIGF1dG8gaWNvblVSTCA9 IFtOU1VSTCBVUkxXaXRoU3RyaW5nOkAidGVzdC1yZXNvdXJjZTovL1NlY29uZEV4dGVuc2lvbi9J bnNwZWN0b3JFeHRlbnNpb24tVGFiSWNvbi0zMHgzMC5wbmciXTsKKyAgICBhdXRvIHNvdXJjZVVS TCA9IFtOU1VSTCBVUkxXaXRoU3RyaW5nOkAidGVzdC1yZXNvdXJjZTovL1NlY29uZEV4dGVuc2lv bi9JbnNwZWN0b3JFeHRlbnNpb24tYmFzaWMtdGFiLmh0bWwiXTsKKworICAgIHBlbmRpbmdDYWxs YmFja1dhc0NhbGxlZCA9IGZhbHNlOworICAgIFtzaGFyZWRJbnNwZWN0b3JFeHRlbnNpb24gY3Jl YXRlVGFiV2l0aE5hbWU6QCJTZWNvbmRFeHRlbnNpb24tVGFiIiB0YWJJY29uVVJMOmljb25VUkwg c291cmNlVVJMOnNvdXJjZVVSTCBjb21wbGV0aW9uSGFuZGxlcjpeKE5TRXJyb3IgKiBfTnVsbGFi bGUgZXJyb3IsIE5TU3RyaW5nICogX051bGxhYmxlIGV4dGVuc2lvblRhYklkZW50aWZpZXIpIHsK KyAgICAgICAgRVhQRUNUX05VTEwoZXJyb3IpOworICAgICAgICBFWFBFQ1RfTk9UX05VTEwoZXh0 ZW5zaW9uVGFiSWRlbnRpZmllcik7CisgICAgICAgIHNoYXJlZEV4dGVuc2lvblRhYklkZW50aWZp ZXIgPSBleHRlbnNpb25UYWJJZGVudGlmaWVyOworCisgICAgICAgIHBlbmRpbmdDYWxsYmFja1dh c0NhbGxlZCA9IHRydWU7CisgICAgfV07CisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZw ZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQpOworCisgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVk ID0gZmFsc2U7CisgICAgZGlkU2hvd0V4dGVuc2lvblRhYldhc0NhbGxlZCA9IGZhbHNlOworICAg IFtbd2ViVmlldyBfaW5zcGVjdG9yXSBzaG93RXh0ZW5zaW9uVGFiV2l0aElkZW50aWZpZXI6c2hh cmVkRXh0ZW5zaW9uVGFiSWRlbnRpZmllci5nZXQoKSBjb21wbGV0aW9uSGFuZGxlcjpeKE5TRXJy b3IgKiBfTnVsbGFibGUgZXJyb3IpIHsKKyAgICAgICAgRVhQRUNUX05VTEwoZXJyb3IpOworCisg ICAgICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IHRydWU7CisgICAgfV07CisgICAgVGVz dFdlYktpdEFQSTo6VXRpbDo6cnVuKCZwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQpOworICAgIFRl c3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmZGlkU2hvd0V4dGVuc2lvblRhYldhc0NhbGxlZCk7CisK KyAgICBhdXRvIHNjcmlwdFNvdXJjZSA9IEAiISF3aW5kb3cuZ2V0VW5pcXVlVmFsdWUgJiYgd2lu ZG93LmdldFVuaXF1ZVZhbHVlKCkiOworCisgICAgLy8gUmVhZCBiYWNrIGEgdmFsdWUgdGhhdCBp cyB1bmlxdWUgdG8gdGhlIDxpZnJhbWU+J3Mgc2NyaXB0IGNvbnRleHQuCisgICAgcGVuZGluZ0Nh bGxiYWNrV2FzQ2FsbGVkID0gZmFsc2U7CisgICAgW3NoYXJlZEluc3BlY3RvckV4dGVuc2lvbiBf ZXZhbHVhdGVTY3JpcHQ6c2NyaXB0U291cmNlIGluRXh0ZW5zaW9uVGFiV2l0aElkZW50aWZpZXI6 c2hhcmVkRXh0ZW5zaW9uVGFiSWRlbnRpZmllci5nZXQoKSBjb21wbGV0aW9uSGFuZGxlcjpeKE5T RXJyb3IgKiBfTnVsbGFibGUgZXJyb3IsIE5TRGljdGlvbmFyeSAqIF9OdWxsYWJsZSByZXN1bHQp IHsKKyAgICAgICAgRVhQRUNUX05VTEwoZXJyb3IpOworICAgICAgICBFWFBFQ1RfTk9UX05VTEwo cmVzdWx0KTsKKyAgICAgICAgZXZhbHVhdGlvblJlc3VsdCA9IHJlc3VsdDsKKworICAgICAgICBw ZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSB0cnVlOworICAgIH1dOworICAgIFRlc3RXZWJLaXRB UEk6OlV0aWw6OnJ1bigmcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkKTsKKworICAgIC8vIENhdXNl IHRoZSBleHRlbnNpb24gdGFiIHRvIGJlIGhpZGRlbi4gSXRzIDxpZnJhbWU+IHNob3VsZCBub3Qg ZGV0YWNoIGZyb20gdGhlIERPTS4KKyAgICBbW3dlYlZpZXcgX2luc3BlY3Rvcl0gc2hvd0NvbnNv bGVdOworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmZGlkSGlkZUV4dGVuc2lvblRhYldh c0NhbGxlZCk7CisKKyAgICAvLyBDaGVjayB0aGUgdW5pcXVlIHZhbHVlIGFnYWluLCB3aGlsZSB0 aGUgPGlmcmFtZT4gaXMgYmVpbmcgaGlkZGVuLiBJZiB0aGUgPGlmcmFtZT4gaXMKKyAgICAvLyBk ZXRhY2hlZCBmcm9tIHRoZSBET00sIHRoZW4gdGhpcyBldmFsdWF0aW9uIHdpbGwgZmFpbCBvciBo YW5nLgorICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IGZhbHNlOworICAgIFtzaGFyZWRJ bnNwZWN0b3JFeHRlbnNpb24gX2V2YWx1YXRlU2NyaXB0OnNjcmlwdFNvdXJjZSBpbkV4dGVuc2lv blRhYldpdGhJZGVudGlmaWVyOnNoYXJlZEV4dGVuc2lvblRhYklkZW50aWZpZXIuZ2V0KCkgY29t cGxldGlvbkhhbmRsZXI6XihOU0Vycm9yICogX051bGxhYmxlIGVycm9yLCBOU0RpY3Rpb25hcnkg KiBfTnVsbGFibGUgcmVzdWx0KSB7CisgICAgICAgIEVYUEVDVF9OVUxMKGVycm9yKTsKKyAgICAg ICAgRVhQRUNUX05PVF9OVUxMKHJlc3VsdCk7CisgICAgICAgIEVYUEVDVF9OU19FUVVBTChyZXN1 bHQsIGV2YWx1YXRpb25SZXN1bHQuZ2V0KCkpOworCisgICAgICAgIHBlbmRpbmdDYWxsYmFja1dh c0NhbGxlZCA9IHRydWU7CisgICAgfV07CisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZw ZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQpOworCisgICAgLy8gUmVzZWxlY3QgdGhlIGV4dGVuc2lv biB0YWIuCisgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gZmFsc2U7CisgICAgZGlkU2hv d0V4dGVuc2lvblRhYldhc0NhbGxlZCA9IGZhbHNlOworICAgIFtbd2ViVmlldyBfaW5zcGVjdG9y XSBzaG93RXh0ZW5zaW9uVGFiV2l0aElkZW50aWZpZXI6c2hhcmVkRXh0ZW5zaW9uVGFiSWRlbnRp Zmllci5nZXQoKSBjb21wbGV0aW9uSGFuZGxlcjpeKE5TRXJyb3IgKiBfTnVsbGFibGUgZXJyb3Ip IHsKKyAgICAgICAgRVhQRUNUX05VTEwoZXJyb3IpOworCisgICAgICAgIHBlbmRpbmdDYWxsYmFj a1dhc0NhbGxlZCA9IHRydWU7CisgICAgfV07CisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVu KCZwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQpOworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1 bigmZGlkU2hvd0V4dGVuc2lvblRhYldhc0NhbGxlZCk7CisKKyAgICAvLyBDaGVjayB0aGUgdW5p cXVlIHZhbHVlIGFnYWluIGFmdGVyIHJlc2VsZWN0aW5nIHRoZSBleHRlbnNpb24gdGFiLgorICAg IHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IGZhbHNlOworICAgIFtzaGFyZWRJbnNwZWN0b3JF eHRlbnNpb24gX2V2YWx1YXRlU2NyaXB0OnNjcmlwdFNvdXJjZSBpbkV4dGVuc2lvblRhYldpdGhJ ZGVudGlmaWVyOnNoYXJlZEV4dGVuc2lvblRhYklkZW50aWZpZXIuZ2V0KCkgY29tcGxldGlvbkhh bmRsZXI6XihOU0Vycm9yICogX051bGxhYmxlIGVycm9yLCBOU0RpY3Rpb25hcnkgKiBfTnVsbGFi bGUgcmVzdWx0KSB7CisgICAgICAgIEVYUEVDVF9OVUxMKGVycm9yKTsKKyAgICAgICAgRVhQRUNU X05PVF9OVUxMKHJlc3VsdCk7CisgICAgICAgIEVYUEVDVF9OU19FUVVBTChyZXN1bHQsIGV2YWx1 YXRpb25SZXN1bHQuZ2V0KCkpOworCisgICAgICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9 IHRydWU7CisgICAgfV07CisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZwZW5kaW5nQ2Fs bGJhY2tXYXNDYWxsZWQpOworCisgICAgLy8gVW5yZWdpc3RlciB0aGUgdGVzdCBleHRlbnNpb24u CisgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gZmFsc2U7CisgICAgW1t3ZWJWaWV3IF9p bnNwZWN0b3JdIHVucmVnaXN0ZXJFeHRlbnNpb246c2hhcmVkSW5zcGVjdG9yRXh0ZW5zaW9uLmdl dCgpIGNvbXBsZXRpb25IYW5kbGVyOl4oTlNFcnJvciAqIF9OdWxsYWJsZSBlcnJvcikgeworICAg ICAgICBFWFBFQ1RfTlVMTChlcnJvcik7CisKKyAgICAgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2Fs bGVkID0gdHJ1ZTsKKyAgICB9XTsKKyAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJnBlbmRp bmdDYWxsYmFja1dhc0NhbGxlZCk7Cit9CisKICNlbmRpZiAvLyBFTkFCTEUoSU5TUEVDVE9SX0VY VEVOU0lPTlMpCg== 440255 2021-10-05 13:25:13 -0700 2021-10-07 10:54:50 -0700 Patch v1.2 bug-230758-20211005132512.patch text/plain 19695 bburg U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzNTY4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkluc3BlY3RvclVJL0NoYW5nZUxvZwppbmRleCAy ZTZjYzU2NzA0M2VmNzk1MzRlOGYyNmVjNWI5ZDg3MDViNzA5MDI3Li4xMmQ1MWFmNWNiNzI4OTVj ZTI1ZWNkMDAyN2RlODQ5NWZmMmIzYWUwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9y VUkvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKQEAgLTEs MyArMSw0NCBAQAorMjAyMS0xMC0wNSAgQkogQnVyZyAgPGJidXJnQGFwcGxlLmNvbT4KKworICAg ICAgICBXZWIgSW5zcGVjdG9yOiBXZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50VmlldyBz aG91bGQgbm90IHJlbG9hZCBpdHMgaWZyYW1lIHdoZW4gZGV0YWNoZWQKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzMDc1OAorICAgICAgICA8cmRhcjov Lzc0NzE0ODYxPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIFdoZW4gYW4gPGlmcmFtZT4gZWxlbWVudCBkZXRhY2hlcyBmcm9tIHRoZSBET00sIHRoZSBz Y3JpcHQgY29udGV4dCBpcyBkZXN0cm95ZWQsIHdoaWNoIHdlIGRvbid0CisgICAgICAgIHdhbnQg dG8gaGFwcGVuIGZvciBfV0tJbnNwZWN0b3JFeHRlbnNpb24gdGFicy4gRml4IHRoaXMgYnkgdGVh Y2hpbmcgQ29udGVudFZpZXdDb250YWluZXIgdG8KKyAgICAgICAgJ2hpZGUnIHN1Y2ggY29udGVu dCB2aWV3cyBieSBzZXR0aW5nIGBkaXNwbGF5Om5vbmVgIHJhdGhlciB0aGFuIGRldGFjaGluZyBm cm9tIHRoZSBET00uCisKKyAgICAgICAgKiBVc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3 Q29udGFpbmVyLmpzOgorICAgICAgICAoV0kuQ29udGVudFZpZXdDb250YWluZXIucHJvdG90eXBl Ll9zaG93RW50cnkpOgorICAgICAgICAoV0kuQ29udGVudFZpZXdDb250YWluZXIucHJvdG90eXBl Ll9oaWRlRW50cnkpOgorICAgICAgICBTZXQgYW5kIHVuc2V0ICdkaXNwbGF5Om5vbmUnIGluc3Rl YWQgb2YgY2FsbGluZyBhZGRTdWJ2aWV3KCkgLyByZW1vdmVTdWJ2aWV3KCkuCisKKyAgICAgICAg KiBVc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmNzczoKKyAgICAgICAg KC5jb250ZW50LXZpZXctY29udGFpbmVyID4gLmNvbnRlbnQtdmlldy5oaWRkZW4tZm9yLWRldGFj aCk6IEFkZGVkLgorCisgICAgICAgIChXSS5Db250ZW50Vmlld0NvbnRhaW5lci5wcm90b3R5cGUu X2Rpc2Fzc29jaWF0ZUZyb21Db250ZW50Vmlldyk6CisgICAgICAgIENsZWFuIHVwIGFueSByZW1h aW5pbmcgY29udGVudCB2aWV3cyB0aGF0IHdlcmUgbm90IGRldGFjaGVkIGR1ZSB0byBvdmVycmlk aW5nIHNob3VsZE5vdFJlbW92ZUZyb21ET01XaGVuSGlkZGVuLgorCisgICAgICAgICogVXNlcklu dGVyZmFjZS9WaWV3cy9Db250ZW50Vmlldy5qczoKKyAgICAgICAgKFdJLkNvbnRlbnRWaWV3LnBy b3RvdHlwZS5nZXQgc2hvdWxkTm90UmVtb3ZlRnJvbURPTVdoZW5IaWRkZW4pOiBBZGRlZC4KKwor ICAgICAgICAqIFVzZXJJbnRlcmZhY2UvVmlld3MvV2ViSW5zcGVjdG9yRXh0ZW5zaW9uVGFiQ29u dGVudFZpZXcuanM6CisgICAgICAgIChXSS5XZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50 Vmlldyk6CisgICAgICAgIChXSS5XZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50Vmlldy5w cm90b3R5cGUuZ2V0IHNob3VsZE5vdFJlbW92ZUZyb21ET01XaGVuSGlkZGVuKToKKyAgICAgICAg T3ZlcnJpZGUgdGhpcyB0byBvcHQgaW50byB0aGUgYWx0ZXJuYXRlIGJlaGF2aW9yIHRoYXQgZG9l cyBub3QgZGV0YWNoIGZyb20gdGhlIERPTS4gSXQgaXMgc3RpbGwKKyAgICAgICAgbmVjZXNzYXJ5 IHRvIGNhbGwgYXR0YWNoZWQoKSBhbmQgZGV0YWNoZWQoKSBzbyB0aGF0IFdlYklucGVjdG9yRXh0 ZW5zaW9uVGFiQ29udGVudFZpZXcgY2FuIGdlbmVyYXRlCisgICAgICAgIGRpZFNob3dFeHRlbnNp b25UYWIvZGlkSGlkZUV4dGVuc2lvblRhYiBldmVudCBjYWxsYmFja3MuCisKKyAgICAgICAgKiBV c2VySW50ZXJmYWNlL0NvbnRyb2xsZXJzL1dlYkluc3BlY3RvckV4dGVuc2lvbkNvbnRyb2xsZXIu anM6CisgICAgICAgIChXSS5XZWJJbnNwZWN0b3JFeHRlbnNpb25Db250cm9sbGVyLnByb3RvdHlw ZS5nZXQgcmVnaXN0ZXJlZEV4dGVuc2lvbklEcyk6CisgICAgICAgICogVXNlckludGVyZmFjZS9E ZWJ1Zy9Cb290c3RyYXAuanM6CisgICAgICAgICh1cGRhdGVNb2NrV2ViRXh0ZW5zaW9uVGFiKToK KyAgICAgICAgKFdJLnJ1bkJvb3RzdHJhcE9wZXJhdGlvbnMpOgorICAgICAgICBUaGlzIGlzIGEg ZHJpdmUtYnkgZml4IHRvIGFkZHJlc3MgYSBjb25zb2xlIGFzc2VydGlvbiBzZWVuIHdoaWxlIGRl dmVsb3BpbmcgdGhlIEFQSSB0ZXN0LgorICAgICAgICBEb24ndCB1bnJlZ2lzdGVyIHRoZSBtb2Nr IGV4dGVuc2lvbiBpZiBpdCBpcyBub3QgcmVnaXN0ZXJlZCBpbiB0aGUgZmlyc3QgcGxhY2UuCisK IDIwMjEtMDktMjkgIEJKIEJ1cmcgIDxiYnVyZ0BhcHBsZS5jb20+CiAKICAgICAgICAgW0NvY29h XSBhZGQgX1dLSW5zcGVjdG9yRXh0ZW5zaW9uIFNQSSB0byBldmFsdWF0ZSBzY3JpcHQgb24gYW4g ZXh0ZW5zaW9uIHRhYgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRl cmZhY2UvQ29udHJvbGxlcnMvV2ViSW5zcGVjdG9yRXh0ZW5zaW9uQ29udHJvbGxlci5qcyBiL1Nv dXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL0NvbnRyb2xsZXJzL1dlYkluc3BlY3Rv ckV4dGVuc2lvbkNvbnRyb2xsZXIuanMKaW5kZXggNTc1YjQwODI3YzUxN2QyYWFlNzU2NjlkMDI1 ZTI5OWI4OTdjNThmMC4uZWFmMjY5OTJiMTE2NDZhMDExOGQ0ZWNhMjJhZWY3YzM3ODU1ZWQ3ZCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvQ29udHJvbGxl cnMvV2ViSW5zcGVjdG9yRXh0ZW5zaW9uQ29udHJvbGxlci5qcworKysgYi9Tb3VyY2UvV2ViSW5z cGVjdG9yVUkvVXNlckludGVyZmFjZS9Db250cm9sbGVycy9XZWJJbnNwZWN0b3JFeHRlbnNpb25D b250cm9sbGVyLmpzCkBAIC0zNyw2ICszNywxMSBAQCBXSS5XZWJJbnNwZWN0b3JFeHRlbnNpb25D b250cm9sbGVyID0gY2xhc3MgV2ViSW5zcGVjdG9yRXh0ZW5zaW9uQ29udHJvbGxlciBleHRlbgog CiAgICAgLy8gUHVibGljCiAKKyAgICBnZXQgcmVnaXN0ZXJlZEV4dGVuc2lvbklEcygpCisgICAg eworICAgICAgICByZXR1cm4gbmV3IFNldCh0aGlzLl9leHRlbnNpb25Gb3JFeHRlbnNpb25JRE1h cC5rZXlzKCkpOworICAgIH0KKwogICAgIHJlZ2lzdGVyRXh0ZW5zaW9uKGV4dGVuc2lvbklELCBk aXNwbGF5TmFtZSkKICAgICB7CiAgICAgICAgIGlmICh0aGlzLl9leHRlbnNpb25Gb3JFeHRlbnNp b25JRE1hcC5oYXMoZXh0ZW5zaW9uSUQpKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvVXNlckludGVyZmFjZS9EZWJ1Zy9Cb290c3RyYXAuanMgYi9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvVXNlckludGVyZmFjZS9EZWJ1Zy9Cb290c3RyYXAuanMKaW5kZXggOGQ0NDAzNmViYTNj ZGQ1YjBhZjU2MTkyNTQyYmQxZDU3NTVjOTYxNi4uYWQzMTVhNDFiYWM2YjM2YTJlZDdiY2VjMDIz ZjMzYjdjYTAwNjQ2NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRl cmZhY2UvRGVidWcvQm9vdHN0cmFwLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2Vy SW50ZXJmYWNlL0RlYnVnL0Jvb3RzdHJhcC5qcwpAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5 cmlnaHQgKEMpIDIwMTUgVW5pdmVyc2l0eSBvZiBXYXNoaW5ndG9uLgorICogQ29weXJpZ2h0IChD KSAyMDIxIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK ICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucwpAQCAtMTUwLDcgKzE1MSw5IEBAIFdJLnJ1bkJvb3RzdHJhcE9wZXJhdGlv bnMgPSBmdW5jdGlvbigpIHsKIAogICAgICAgICAvLyBTaW11bGF0ZXMgdGhlIHN0ZXBzIHRha2Vu IGJ5IFdlYkluc3BlY3RvclVJRXh0ZW5zaW9uQ29udHJvbGxlciB0byBjcmVhdGUgYW4gZXh0ZW5z aW9uIHRhYiBpbiBXZWJJbnNwZWN0b3JVSS4KICAgICAgICAgaWYgKCFXSS5zZXR0aW5ncy5lbmdp bmVlcmluZ1Nob3dNb2NrV2ViRXh0ZW5zaW9uVGFiLnZhbHVlKSB7Ci0gICAgICAgICAgICBJbnNw ZWN0b3JGcm9udGVuZEFQSS51bnJlZ2lzdGVyRXh0ZW5zaW9uKG1vY2tEYXRhLmV4dGVuc2lvbklE KTsKKyAgICAgICAgICAgIGlmIChXSS5zaGFyZWRBcHAuZXh0ZW5zaW9uQ29udHJvbGxlci5yZWdp c3RlcmVkRXh0ZW5zaW9uSURzLmhhcyhtb2NrRGF0YS5leHRlbnNpb25JRCkpCisgICAgICAgICAg ICAgICAgSW5zcGVjdG9yRnJvbnRlbmRBUEkudW5yZWdpc3RlckV4dGVuc2lvbihtb2NrRGF0YS5l eHRlbnNpb25JRCk7CisKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9Db250ZW50Vmll dy5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRW aWV3LmpzCmluZGV4IDA1MzlhNWZlNDQxMDQzZTM4NTA3MzdjMmVhMTUwNDRlYWFmYTdjOGQuLjIz NzhiOGIyNmRiMzI4M2M5NTgxNWVhZjc2M2M4MGQyMWU4OWVjYWQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3LmpzCisrKyBi L1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Lmpz CkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMywgMjAxNSBBcHBsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTMtMjAyMSBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKQEAgLTQyLDYgKzQyLDEzIEBAIFdJLkNvbnRlbnRWaWV3ID0gY2xhc3MgQ29udGVudFZpZXcg ZXh0ZW5kcyBXSS5WaWV3CiAKICAgICAvLyBTdGF0aWMKIAorICAgIC8vIEltcGxlbWVudGVkIGJ5 IHN1YmNsYXNzZXMuCisgICAgc3RhdGljIHNob3VsZE5vdFJlbW92ZUZyb21ET01XaGVuSGlkZGVu KCkKKyAgICB7CisgICAgICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgY29udGVudCB2aWV3IHNo b3VsZCAqbm90KiBiZSBkZXRhY2hlZCBmcm9tIHRoZSBET00gd2hlbiBoaWRkZW4uCisgICAgICAg IHJldHVybiBmYWxzZTsKKyAgICB9CisKICAgICBzdGF0aWMgY3JlYXRlRnJvbVJlcHJlc2VudGVk T2JqZWN0KHJlcHJlc2VudGVkT2JqZWN0LCBleHRyYUFyZ3VtZW50cykKICAgICB7CiAgICAgICAg IGNvbnNvbGUuYXNzZXJ0KHJlcHJlc2VudGVkT2JqZWN0KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmNz cyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3 Q29udGFpbmVyLmNzcwppbmRleCAzYmVhYjFhOGM1NTAxOTNlOGIwNTY1MThlMDYyYWMyZDk1NjA0 OGMxLi5hNDQ4YTE1YTA3NGMwM2IyZjIzZTc1ZDk2ZDRiZjA1ZmUyNzk2N2QzIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9Db250ZW50Vmlld0Nv bnRhaW5lci5jc3MKKysrIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvVmll d3MvQ29udGVudFZpZXdDb250YWluZXIuY3NzCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHly aWdodCAoQykgMjAxMyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmln aHQgKEMpIDIwMTMtMjAyMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTM3LDMgKzM3LDcgQEAKIAogICAgIG92ZXJmbG93 OiBoaWRkZW47CiB9CisKKy5jb250ZW50LXZpZXctY29udGFpbmVyID4gLmNvbnRlbnQtdmlldy5o aWRkZW4tc2ltdWxhdGluZy1kb20tZGV0YWNoZWQgeworICAgIGRpc3BsYXk6IG5vbmU7Cit9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9Db250 ZW50Vmlld0NvbnRhaW5lci5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNl L1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmpzCmluZGV4IGFiMDU2ZWY5MzUyMTVhZDA5MDQz YTg3ZmM5NzYyMGJjN2U4NGYwNTAuLjgxZDlmODBiNzlkOGFlZmVjNDEwNTEyZWJmNmI3Zjk3NmJi NzI2NWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1Zp ZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9V c2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmpzCkBAIC00MjEsNiArNDIx LDExIEBAIFdJLkNvbnRlbnRWaWV3Q29udGFpbmVyID0gY2xhc3MgQ29udGVudFZpZXdDb250YWlu ZXIgZXh0ZW5kcyBXSS5WaWV3CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KIAorICAg ICAgICAvLyBEZXNlbGVjdGVkIGV4dGVuc2lvbiB0YWJzIGFyZSBzdGlsbCBhdHRhY2hlZCB0byB0 aGUgRE9NIHZpYSBgdGhpcy5lbGVtZW50YCwKKyAgICAgICAgLy8gc28gdGhpcyBpcyB0aGUgbGFz dCBjaGFuY2UgdG8gYWN0dWFsbHkgcmVtb3ZlIHRoZSBzdWJ2aWV3IGFuZCBkZXRhY2ggZnJvbSB0 aGUgRE9NLgorICAgICAgICBpZiAoY29udGVudFZpZXcuY29uc3RydWN0b3Iuc2hvdWxkTm90UmVt b3ZlRnJvbURPTVdoZW5IaWRkZW4oKSAmJiBjb250ZW50Vmlldy5pc0F0dGFjaGVkKQorICAgICAg ICAgICAgdGhpcy5yZW1vdmVTdWJ2aWV3KGNvbnRlbnRWaWV3KTsKKwogICAgICAgICBjb25zb2xl LmFzc2VydCghY29udGVudFZpZXcuaXNBdHRhY2hlZCk7CiAKICAgICAgICAgaWYgKCFjb250ZW50 Vmlldy5fcGFyZW50Q29udGFpbmVyKQpAQCAtNDU3LDYgKzQ2MiwxMCBAQCBXSS5Db250ZW50Vmll d0NvbnRhaW5lciA9IGNsYXNzIENvbnRlbnRWaWV3Q29udGFpbmVyIGV4dGVuZHMgV0kuVmlldwog CiAgICAgICAgIGlmICghdGhpcy5zdWJ2aWV3cy5pbmNsdWRlcyhlbnRyeS5jb250ZW50Vmlldykp CiAgICAgICAgICAgICB0aGlzLmFkZFN1YnZpZXcoZW50cnkuY29udGVudFZpZXcpOworICAgICAg ICBlbHNlIGlmIChlbnRyeS5jb250ZW50Vmlldy5jb25zdHJ1Y3Rvci5zaG91bGROb3RSZW1vdmVG cm9tRE9NV2hlbkhpZGRlbigpKSB7CisgICAgICAgICAgICBlbnRyeS5jb250ZW50Vmlldy5lbGVt ZW50LmNsYXNzTGlzdC5yZW1vdmUoImhpZGRlbi1zaW11bGF0aW5nLWRvbS1kZXRhY2hlZCIpOwor ICAgICAgICAgICAgZW50cnkuY29udGVudFZpZXcuX2RpZE1vdmVUb1BhcmVudCh0aGlzKTsKKyAg ICAgICAgfQogCiAgICAgICAgIGVudHJ5LnByZXBhcmVUb1Nob3coKTsKICAgICB9CkBAIC00NzEs OCArNDgwLDEzIEBAIFdJLkNvbnRlbnRWaWV3Q29udGFpbmVyID0gY2xhc3MgQ29udGVudFZpZXdD b250YWluZXIgZXh0ZW5kcyBXSS5WaWV3CiAgICAgICAgICAgICByZXR1cm47CiAKICAgICAgICAg ZW50cnkucHJlcGFyZVRvSGlkZSgpOwotICAgICAgICBpZiAodGhpcy5zdWJ2aWV3cy5pbmNsdWRl cyhlbnRyeS5jb250ZW50VmlldykpCi0gICAgICAgICAgICB0aGlzLnJlbW92ZVN1YnZpZXcoZW50 cnkuY29udGVudFZpZXcpOworICAgICAgICBpZiAodGhpcy5zdWJ2aWV3cy5pbmNsdWRlcyhlbnRy eS5jb250ZW50VmlldykpIHsKKyAgICAgICAgICAgIGlmIChlbnRyeS5jb250ZW50Vmlldy5jb25z dHJ1Y3Rvci5zaG91bGROb3RSZW1vdmVGcm9tRE9NV2hlbkhpZGRlbigpKSB7CisgICAgICAgICAg ICAgICAgZW50cnkuY29udGVudFZpZXcuZWxlbWVudC5jbGFzc0xpc3QuYWRkKCJoaWRkZW4tc2lt dWxhdGluZy1kb20tZGV0YWNoZWQiKTsKKyAgICAgICAgICAgICAgICBlbnRyeS5jb250ZW50Vmll dy5fZGlkTW92ZVRvUGFyZW50KG51bGwpOworICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAg ICAgICAgdGhpcy5yZW1vdmVTdWJ2aWV3KGVudHJ5LmNvbnRlbnRWaWV3KTsKKyAgICAgICAgfQog ICAgIH0KIAogICAgIF90b21ic3RvbmVDb250ZW50Vmlld0NvbnRhaW5lcnNGb3JDb250ZW50Vmll dyhjb250ZW50VmlldykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50 ZXJmYWNlL1ZpZXdzL1RhYkJyb3dzZXIuanMgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlcklu dGVyZmFjZS9WaWV3cy9UYWJCcm93c2VyLmpzCmluZGV4IGFlYTI1MmIxNmZjMmIxZDllNTVmNDFj ZDMzODY3NWI3MjQwOWZjNWEuLjgwNGQzYmJmMTNhMzcxODljM2JjMjQ1MjUxMTlkYmMwMWY5MDQ0 MTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdz L1RhYkJyb3dzZXIuanMKKysrIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2Uv Vmlld3MvVGFiQnJvd3Nlci5qcwpAQCAtMTcxLDcgKzE3MSw5IEBAIFdJLlRhYkJyb3dzZXIgPSBj bGFzcyBUYWJCcm93c2VyIGV4dGVuZHMgV0kuVmlldwogICAgICAgICAgICAgdGhpcy5fdGFiQmFy LmFkZFRhYkJhckl0ZW0odGFiQmFySXRlbSwgb3B0aW9ucyk7CiAKICAgICAgICAgY29uc29sZS5h c3NlcnQodGhpcy5fcmVjZW50VGFiQ29udGVudFZpZXdzLmxlbmd0aCA9PT0gdGhpcy5fdGFiQmFy LnRhYkNvdW50KTsKLSAgICAgICAgY29uc29sZS5hc3NlcnQoIXRoaXMuc2VsZWN0ZWRUYWJDb250 ZW50VmlldyB8fCB0aGlzLnNlbGVjdGVkVGFiQ29udGVudFZpZXcgPT09IHRoaXMuX3JlY2VudFRh YkNvbnRlbnRWaWV3c1swXSk7CisKKyAgICAgICAgbGV0IHNob3VsZFNhdmVUYWIgPSB0aGlzLnNl bGVjdGVkVGFiQ29udGVudFZpZXc/LmNvbnN0cnVjdG9yLnNob3VsZFNhdmVUYWIoKSB8fCB0aGlz LnNlbGVjdGVkVGFiQ29udGVudFZpZXc/LmNvbnN0cnVjdG9yLnNob3VsZFBpblRhYigpOworICAg ICAgICBjb25zb2xlLmFzc2VydCghdGhpcy5zZWxlY3RlZFRhYkNvbnRlbnRWaWV3IHx8IHRoaXMu c2VsZWN0ZWRUYWJDb250ZW50VmlldyA9PT0gdGhpcy5fcmVjZW50VGFiQ29udGVudFZpZXdzWzBd IHx8ICFzaG91bGRTYXZlVGFiKTsKIAogICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9XZWJJbnNw ZWN0b3JFeHRlbnNpb25UYWJDb250ZW50Vmlldy5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9V c2VySW50ZXJmYWNlL1ZpZXdzL1dlYkluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3Lmpz CmluZGV4IDc0YWZhNGNjZmJkMjhjZjYzNGIxODczNDhkMDY1NzBiNmViZTIwYWUuLmJhMWYzNzky ZmJjZWJlMzdmNzc3OWU1Y2E2MTE0NzEzODQxZTAyYzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJ bnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL1dlYkluc3BlY3RvckV4dGVuc2lvblRhYkNv bnRlbnRWaWV3LmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1Zp ZXdzL1dlYkluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3LmpzCkBAIC00MCw5ICs0MCw2 IEBAIFdJLldlYkluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3ID0gY2xhc3MgV2ViSW5z cGVjdG9yRXh0ZW5zaW9uVGFiQ29udGVudFZpCiAgICAgICAgIHRoaXMuX3RhYkluZm8gPSB0YWJJ bmZvOwogICAgICAgICB0aGlzLl9zb3VyY2VVUkwgPSBzb3VyY2VVUkw7CiAKLSAgICAgICAgLy8g RklYTUU6IHRoZSA8aWZyYW1lPidzIGRvY3VtZW50IGlzIGltcGxpY2l0bHkgcmVsb2FkZWQgd2hl biB0aGlzCi0gICAgICAgIC8vIGNvbnRlbnQgdmlldydzIGVsZW1lbnQgaXMgZGV0YWNoZWQgYW5k IGxhdGVyIHJlLWF0dGFjaGVkIHRvIHRoZSBET00uCi0gICAgICAgIC8vIFRoaXMgaXMgYSBidWcg YW5kIHdpbGwgYmUgYWRkcmVzc2VkIGluIDxodHRwczovL3dlYmtpdC5vcmcvYi8yMzA3NTg+Lgog ICAgICAgICB0aGlzLl9pZnJhbWVFbGVtZW50ID0gdGhpcy5lbGVtZW50LmFwcGVuZENoaWxkKGRv Y3VtZW50LmNyZWF0ZUVsZW1lbnQoImlmcmFtZSIpKTsKICAgICAgICAgdGhpcy5faWZyYW1lRWxl bWVudC5hZGRFdmVudExpc3RlbmVyKCJsb2FkIiwgdGhpcy5fZXh0ZW5zaW9uRnJhbWVEaWRMb2Fk LmJpbmQodGhpcykpOwogICAgICAgICB0aGlzLl9pZnJhbWVFbGVtZW50LnNyYyA9IHRoaXMuX3Nv dXJjZVVSTDsKQEAgLTg3LDYgKzg0LDEyIEBAIFdJLldlYkluc3BlY3RvckV4dGVuc2lvblRhYkNv bnRlbnRWaWV3ID0gY2xhc3MgV2ViSW5zcGVjdG9yRXh0ZW5zaW9uVGFiQ29udGVudFZpCiAKICAg ICBzdGF0aWMgc2hvdWxkU2F2ZVRhYigpIHsgcmV0dXJuIGZhbHNlOyB9CiAKKyAgICBzdGF0aWMg c2hvdWxkTm90UmVtb3ZlRnJvbURPTVdoZW5IaWRkZW4oKSB7CisgICAgICAgIC8vIFRoaXMgaXMg bmVjZXNzYXJ5IHRvIGF2b2lkIHRoZSA8aWZyYW1lPiBjb250ZW50IGZyb20gYmVpbmcgcmVsb2Fk ZWQgd2hlbiB0aGUgZXh0ZW5zaW9uIHRhYiBpcyBoaWRkZW4uCisgICAgICAgIHJldHVybiB0cnVl OworICAgIH0KKworCiAgICAgLy8gUHJpdmF0ZQogCiAgICAgX2V4dGVuc2lvbkZyYW1lRGlkTG9h ZCgpCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXgg MWI5N2RkMDlkMzFhMzY0M2JjYjFjNjI1MzE5YjExODc0ZWZhODc3ZC4uOGFjOGYwYjE0MzU5MTk1 MTJhN2RlY2QwNmI5ODcyOTMwYjZmODhlNSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisr KyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIxLTEwLTA1ICBCSiBCdXJn ICA8YmJ1cmdAYXBwbGUuY29tPgorCisgICAgICAgIFdlYiBJbnNwZWN0b3I6IFdlYkluc3BlY3Rv ckV4dGVuc2lvblRhYkNvbnRlbnRWaWV3IHNob3VsZCBub3QgcmVsb2FkIGl0cyBpZnJhbWUgd2hl biBkZXRhY2hlZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjMwNzU4CisgICAgICAgIDxyZGFyOi8vNzQ3MTQ4NjE+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGEgbmV3IHRlc3QgdG8gdmVyaWZ5IHRo YXQgcmUtc2VsZWN0aW5nIGFuIGV4dGVuc2lvbiB0YWIgZG9lcyBub3QgY2F1c2UgaXQgdG8gcmVs b2FkLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9JbnNwZWN0 b3JFeHRlbnNpb24tYmFzaWMtdGFiLmh0bWw6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJLaXRDb2NvYS9XS0luc3BlY3RvckV4dGVuc2lvbi5tbToKKyAgICAgICAgKFRFU1QpOgor CiAyMDIxLTEwLTA1ICBUaW0gSG9ydG9uICA8dGltb3RoeV9ob3J0b25AYXBwbGUuY29tPgogCiAg ICAgICAgIDxtb2RlbD4gc2hvdWxkIGJlIGRyYWdnYWJsZSwgc2ltaWxhciB0byA8aW1nPgpkaWZm IC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9JbnNwZWN0b3JF eHRlbnNpb24tYmFzaWMtdGFiLmh0bWwgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktp dENvY29hL0luc3BlY3RvckV4dGVuc2lvbi1iYXNpYy10YWIuaHRtbAppbmRleCA0MmJmMTlkMGIy Nzc1NDIxOWM1MjJkN2EzYWQwOGEyOWM0YTVhMGU0Li42ZmFhOWZiNDBmNjA1MTRmZWZjM2VhZTRj MTNlY2Y3ZmI0YzJiMWYwIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdENvY29hL0luc3BlY3RvckV4dGVuc2lvbi1iYXNpYy10YWIuaHRtbAorKysgYi9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL0luc3BlY3RvckV4dGVuc2lvbi1iYXNpYy10 YWIuaHRtbApAQCAtMSwxMCArMSwyNCBAQAogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+CisgICAg Ly8gVXNlZCBieSBXS0luc3BlY3RvckV4dGVuc2lvbi5DYW5FdmFsdWF0ZVNjcmlwdEluRXh0ZW5z aW9uVGFiCiAgICAgd2luZG93Ll9zZWNyZXRWYWx1ZSA9IHthbnN3ZXI6NDJ9OworCisgICAgLy8g VXNlZCBieSBXS0luc3BlY3RvckV4dGVuc2lvbi5FeHRlbnNpb25UYWJJc1BlcnNpc3RlbnQKKyAg ICB3aW5kb3cuZ2V0VW5pcXVlVmFsdWUgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgaWYgKCF3aW5k b3cuX2NhY2hlZFVuaXF1ZVZhbHVlKSB7CisgICAgICAgICAgICB3aW5kb3cuX2NhY2hlZFVuaXF1 ZVZhbHVlID0gTWF0aC5mbG9vcihNYXRoLnJhbmRvbSgpICogMTBlOSk7CisgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgidW5pcXVlVmFsdWVGaWVsZCIpLmlubmVyVGV4dCA9IHdp bmRvdy5fY2FjaGVkVW5pcXVlVmFsdWU7CisgICAgICAgIH0KKworICAgICAgICByZXR1cm4gd2lu ZG93Ll9jYWNoZWRVbmlxdWVWYWx1ZTsKKyAgICB9CiA8L3NjcmlwdD4KIDxib2R5PgogPGgxPlRo aXMgaXMgYSB0ZXN0IGV4dGVuc2lvbi48L2gxPgogPHA+SW4gYSBub3JtYWwgZXh0ZW5zaW9uLCB0 aGlzIGFyZWEgd291bGQgc2hvdyB0aGUgZXh0ZW5zaW9uJ3MgdXNlciBpbnRlcmZhY2UuPC9wPgor PHA+VGhlIHVuaXF1ZSB2YWx1ZSBmb3IgdGhpcyBpZnJhbWUncyBleGVjdXRpb24gY29udGV4dCBp czoKKyAgICA8c3BhbiBpZD0idW5pcXVlVmFsdWVGaWVsZCI+VEJEPC9zcGFuPgorPC9wPgogPC9i b2R5PgogPC9odG1sPgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXRDb2NvYS9XS0luc3BlY3RvckV4dGVuc2lvbi5tbSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Q29jb2EvV0tJbnNwZWN0b3JFeHRlbnNpb24ubW0KaW5kZXggMjQyMTcyODhjOWNm YzEwZjk3NWJjNzc4YjE4NDUyNjA3MDRlOTM5Zi4uYTY0MDQ0M2Y0ZWIzOTFiZTNiMGMxNGY0ZjQy YTFiYjU4NDNlYTMxYSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXRDb2NvYS9XS0luc3BlY3RvckV4dGVuc2lvbi5tbQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdENvY29hL1dLSW5zcGVjdG9yRXh0ZW5zaW9uLm1tCkBAIC00Nyw2ICs0Nyw3 IEBAIHN0YXRpYyBib29sIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IGZhbHNlOwogc3RhdGlj IFJldGFpblB0cjxUZXN0SW5zcGVjdG9yVVJMU2NoZW1lSGFuZGxlcj4gc2hhcmVkVVJMU2NoZW1l SGFuZGxlcjsKIHN0YXRpYyBSZXRhaW5QdHI8X1dLSW5zcGVjdG9yRXh0ZW5zaW9uPiBzaGFyZWRJ bnNwZWN0b3JFeHRlbnNpb247CiBzdGF0aWMgUmV0YWluUHRyPE5TU3RyaW5nPiBzaGFyZWRFeHRl bnNpb25UYWJJZGVudGlmaWVyOworc3RhdGljIFJldGFpblB0cjxOU09iamVjdD4gZXZhbHVhdGlv blJlc3VsdDsKIAogc3RhdGljIHZvaWQgcmVzZXRHbG9iYWxTdGF0ZSgpCiB7CkBAIC0xODgsNCAr MTg5LDEyMSBAQCBURVNUKFdLSW5zcGVjdG9yRXh0ZW5zaW9uLCBDYW5FdmFsdWF0ZVNjcmlwdElu RXh0ZW5zaW9uVGFiKQogICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmcGVuZGluZ0NhbGxi YWNrV2FzQ2FsbGVkKTsKIH0KIAorVEVTVChXS0luc3BlY3RvckV4dGVuc2lvbiwgRXh0ZW5zaW9u VGFiSXNQZXJzaXN0ZW50KQoreworICAgIHJlc2V0R2xvYmFsU3RhdGUoKTsKKworICAgIGF1dG8g d2ViVmlld0NvbmZpZ3VyYXRpb24gPSBhZG9wdE5TKFtXS1dlYlZpZXdDb25maWd1cmF0aW9uIG5l d10pOworICAgIHdlYlZpZXdDb25maWd1cmF0aW9uLmdldCgpLnByZWZlcmVuY2VzLl9kZXZlbG9w ZXJFeHRyYXNFbmFibGVkID0gWUVTOworICAgIGF1dG8gd2ViVmlldyA9IGFkb3B0TlMoW1tXS1dl YlZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0TWFrZSgwLCAwLCA4MDAsIDYwMCkgY29u ZmlndXJhdGlvbjp3ZWJWaWV3Q29uZmlndXJhdGlvbi5nZXQoKV0pOworICAgIGF1dG8gdWlEZWxl Z2F0ZSA9IGFkb3B0TlMoW1VJRGVsZWdhdGVGb3JUZXN0aW5nSW5zcGVjdG9yRXh0ZW5zaW9uIG5l d10pOworCisgICAgW3dlYlZpZXcgc2V0VUlEZWxlZ2F0ZTp1aURlbGVnYXRlLmdldCgpXTsKKyAg ICBbd2ViVmlldyBsb2FkSFRNTFN0cmluZzpAIjxoZWFkPjx0aXRsZT5UZXN0IHBhZ2UgdG8gYmUg aW5zcGVjdGVkPC90aXRsZT48L2hlYWQ+PGJvZHk+PHA+RmlsbGVyIGNvbnRlbnQ8L3A+PC9ib2R5 PiIgYmFzZVVSTDpbTlNVUkwgVVJMV2l0aFN0cmluZzpAImh0dHA6Ly9leGFtcGxlLmNvbS8iXV07 CisKKyAgICBbW3dlYlZpZXcgX2luc3BlY3Rvcl0gc2hvd107CisgICAgVGVzdFdlYktpdEFQSTo6 VXRpbDo6cnVuKCZkaWRBdHRhY2hMb2NhbEluc3BlY3RvckNhbGxlZCk7CisKKyAgICBhdXRvIGV4 dGVuc2lvbklEID0gW05TVVVJRCBVVUlEXS5VVUlEU3RyaW5nOworICAgIGF1dG8gZXh0ZW5zaW9u RGlzcGxheU5hbWUgPSBAIlNlY29uZEV4dGVuc2lvbiI7CisKKyAgICAvLyBSZWdpc3RlciB0aGUg dGVzdCBleHRlbnNpb24uCisgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gZmFsc2U7Cisg ICAgW1t3ZWJWaWV3IF9pbnNwZWN0b3JdIHJlZ2lzdGVyRXh0ZW5zaW9uV2l0aElEOmV4dGVuc2lv bklEIGRpc3BsYXlOYW1lOmV4dGVuc2lvbkRpc3BsYXlOYW1lIGNvbXBsZXRpb25IYW5kbGVyOl4o TlNFcnJvciAqIF9OdWxsYWJsZSBlcnJvciwgX1dLSW5zcGVjdG9yRXh0ZW5zaW9uICogX051bGxh YmxlIGV4dGVuc2lvbikgeworICAgICAgICBFWFBFQ1RfTlVMTChlcnJvcik7CisgICAgICAgIEVY UEVDVF9OT1RfTlVMTChleHRlbnNpb24pOworICAgICAgICBzaGFyZWRJbnNwZWN0b3JFeHRlbnNp b24gPSBleHRlbnNpb247CisKKyAgICAgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gdHJ1 ZTsKKyAgICB9XTsKKyAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJnBlbmRpbmdDYWxsYmFj a1dhc0NhbGxlZCk7CisKKyAgICBhdXRvIGV4dGVuc2lvbkRlbGVnYXRlID0gYWRvcHROUyhbSW5z cGVjdG9yRXh0ZW5zaW9uRGVsZWdhdGVGb3JUZXN0aW5nSW5zcGVjdG9yRXh0ZW5zaW9uIG5ld10p OworICAgIFtzaGFyZWRJbnNwZWN0b3JFeHRlbnNpb24gc2V0RGVsZWdhdGU6ZXh0ZW5zaW9uRGVs ZWdhdGUuZ2V0KCldOworCisgICAgLy8gQ3JlYXRlIGFuZCBzaG93IGFuIGV4dGVuc2lvbiB0YWIu CisgICAgYXV0byBpY29uVVJMID0gW05TVVJMIFVSTFdpdGhTdHJpbmc6QCJ0ZXN0LXJlc291cmNl Oi8vU2Vjb25kRXh0ZW5zaW9uL0luc3BlY3RvckV4dGVuc2lvbi1UYWJJY29uLTMweDMwLnBuZyJd OworICAgIGF1dG8gc291cmNlVVJMID0gW05TVVJMIFVSTFdpdGhTdHJpbmc6QCJ0ZXN0LXJlc291 cmNlOi8vU2Vjb25kRXh0ZW5zaW9uL0luc3BlY3RvckV4dGVuc2lvbi1iYXNpYy10YWIuaHRtbCJd OworCisgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gZmFsc2U7CisgICAgW3NoYXJlZElu c3BlY3RvckV4dGVuc2lvbiBjcmVhdGVUYWJXaXRoTmFtZTpAIlNlY29uZEV4dGVuc2lvbi1UYWIi IHRhYkljb25VUkw6aWNvblVSTCBzb3VyY2VVUkw6c291cmNlVVJMIGNvbXBsZXRpb25IYW5kbGVy Ol4oTlNFcnJvciAqIF9OdWxsYWJsZSBlcnJvciwgTlNTdHJpbmcgKiBfTnVsbGFibGUgZXh0ZW5z aW9uVGFiSWRlbnRpZmllcikgeworICAgICAgICBFWFBFQ1RfTlVMTChlcnJvcik7CisgICAgICAg IEVYUEVDVF9OT1RfTlVMTChleHRlbnNpb25UYWJJZGVudGlmaWVyKTsKKyAgICAgICAgc2hhcmVk RXh0ZW5zaW9uVGFiSWRlbnRpZmllciA9IGV4dGVuc2lvblRhYklkZW50aWZpZXI7CisKKyAgICAg ICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gdHJ1ZTsKKyAgICB9XTsKKyAgICBUZXN0V2Vi S2l0QVBJOjpVdGlsOjpydW4oJnBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCk7CisKKyAgICBwZW5k aW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSBmYWxzZTsKKyAgICBkaWRTaG93RXh0ZW5zaW9uVGFiV2Fz Q2FsbGVkID0gZmFsc2U7CisgICAgW1t3ZWJWaWV3IF9pbnNwZWN0b3JdIHNob3dFeHRlbnNpb25U YWJXaXRoSWRlbnRpZmllcjpzaGFyZWRFeHRlbnNpb25UYWJJZGVudGlmaWVyLmdldCgpIGNvbXBs ZXRpb25IYW5kbGVyOl4oTlNFcnJvciAqIF9OdWxsYWJsZSBlcnJvcikgeworICAgICAgICBFWFBF Q1RfTlVMTChlcnJvcik7CisKKyAgICAgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gdHJ1 ZTsKKyAgICB9XTsKKyAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJnBlbmRpbmdDYWxsYmFj a1dhc0NhbGxlZCk7CisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZkaWRTaG93RXh0ZW5z aW9uVGFiV2FzQ2FsbGVkKTsKKworICAgIGF1dG8gc2NyaXB0U291cmNlID0gQCIhIXdpbmRvdy5n ZXRVbmlxdWVWYWx1ZSAmJiB3aW5kb3cuZ2V0VW5pcXVlVmFsdWUoKSI7CisKKyAgICAvLyBSZWFk IGJhY2sgYSB2YWx1ZSB0aGF0IGlzIHVuaXF1ZSB0byB0aGUgPGlmcmFtZT4ncyBzY3JpcHQgY29u dGV4dC4KKyAgICBwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSBmYWxzZTsKKyAgICBbc2hhcmVk SW5zcGVjdG9yRXh0ZW5zaW9uIF9ldmFsdWF0ZVNjcmlwdDpzY3JpcHRTb3VyY2UgaW5FeHRlbnNp b25UYWJXaXRoSWRlbnRpZmllcjpzaGFyZWRFeHRlbnNpb25UYWJJZGVudGlmaWVyLmdldCgpIGNv bXBsZXRpb25IYW5kbGVyOl4oTlNFcnJvciAqIF9OdWxsYWJsZSBlcnJvciwgTlNEaWN0aW9uYXJ5 ICogX051bGxhYmxlIHJlc3VsdCkgeworICAgICAgICBFWFBFQ1RfTlVMTChlcnJvcik7CisgICAg ICAgIEVYUEVDVF9OT1RfTlVMTChyZXN1bHQpOworICAgICAgICBldmFsdWF0aW9uUmVzdWx0ID0g cmVzdWx0OworCisgICAgICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IHRydWU7CisgICAg fV07CisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZwZW5kaW5nQ2FsbGJhY2tXYXNDYWxs ZWQpOworCisgICAgLy8gQ2F1c2UgdGhlIGV4dGVuc2lvbiB0YWIgdG8gYmUgaGlkZGVuLiBJdHMg PGlmcmFtZT4gc2hvdWxkIG5vdCBkZXRhY2ggZnJvbSB0aGUgRE9NLgorICAgIFtbd2ViVmlldyBf aW5zcGVjdG9yXSBzaG93Q29uc29sZV07CisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZk aWRIaWRlRXh0ZW5zaW9uVGFiV2FzQ2FsbGVkKTsKKworICAgIC8vIENoZWNrIHRoZSB1bmlxdWUg dmFsdWUgYWdhaW4sIHdoaWxlIHRoZSA8aWZyYW1lPiBpcyBiZWluZyBoaWRkZW4uIElmIHRoZSA8 aWZyYW1lPiBpcworICAgIC8vIGRldGFjaGVkIGZyb20gdGhlIERPTSwgdGhlbiB0aGlzIGV2YWx1 YXRpb24gd2lsbCBmYWlsIG9yIGhhbmcuCisgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0g ZmFsc2U7CisgICAgW3NoYXJlZEluc3BlY3RvckV4dGVuc2lvbiBfZXZhbHVhdGVTY3JpcHQ6c2Ny aXB0U291cmNlIGluRXh0ZW5zaW9uVGFiV2l0aElkZW50aWZpZXI6c2hhcmVkRXh0ZW5zaW9uVGFi SWRlbnRpZmllci5nZXQoKSBjb21wbGV0aW9uSGFuZGxlcjpeKE5TRXJyb3IgKiBfTnVsbGFibGUg ZXJyb3IsIE5TRGljdGlvbmFyeSAqIF9OdWxsYWJsZSByZXN1bHQpIHsKKyAgICAgICAgRVhQRUNU X05VTEwoZXJyb3IpOworICAgICAgICBFWFBFQ1RfTk9UX05VTEwocmVzdWx0KTsKKyAgICAgICAg RVhQRUNUX05TX0VRVUFMKHJlc3VsdCwgZXZhbHVhdGlvblJlc3VsdC5nZXQoKSk7CisKKyAgICAg ICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gdHJ1ZTsKKyAgICB9XTsKKyAgICBUZXN0V2Vi S2l0QVBJOjpVdGlsOjpydW4oJnBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCk7CisKKyAgICAvLyBS ZXNlbGVjdCB0aGUgZXh0ZW5zaW9uIHRhYi4KKyAgICBwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQg PSBmYWxzZTsKKyAgICBkaWRTaG93RXh0ZW5zaW9uVGFiV2FzQ2FsbGVkID0gZmFsc2U7CisgICAg W1t3ZWJWaWV3IF9pbnNwZWN0b3JdIHNob3dFeHRlbnNpb25UYWJXaXRoSWRlbnRpZmllcjpzaGFy ZWRFeHRlbnNpb25UYWJJZGVudGlmaWVyLmdldCgpIGNvbXBsZXRpb25IYW5kbGVyOl4oTlNFcnJv ciAqIF9OdWxsYWJsZSBlcnJvcikgeworICAgICAgICBFWFBFQ1RfTlVMTChlcnJvcik7CisKKyAg ICAgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gdHJ1ZTsKKyAgICB9XTsKKyAgICBUZXN0 V2ViS2l0QVBJOjpVdGlsOjpydW4oJnBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCk7CisgICAgVGVz dFdlYktpdEFQSTo6VXRpbDo6cnVuKCZkaWRTaG93RXh0ZW5zaW9uVGFiV2FzQ2FsbGVkKTsKKwor ICAgIC8vIENoZWNrIHRoZSB1bmlxdWUgdmFsdWUgYWdhaW4gYWZ0ZXIgcmVzZWxlY3RpbmcgdGhl IGV4dGVuc2lvbiB0YWIuCisgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gZmFsc2U7Cisg ICAgW3NoYXJlZEluc3BlY3RvckV4dGVuc2lvbiBfZXZhbHVhdGVTY3JpcHQ6c2NyaXB0U291cmNl IGluRXh0ZW5zaW9uVGFiV2l0aElkZW50aWZpZXI6c2hhcmVkRXh0ZW5zaW9uVGFiSWRlbnRpZmll ci5nZXQoKSBjb21wbGV0aW9uSGFuZGxlcjpeKE5TRXJyb3IgKiBfTnVsbGFibGUgZXJyb3IsIE5T RGljdGlvbmFyeSAqIF9OdWxsYWJsZSByZXN1bHQpIHsKKyAgICAgICAgRVhQRUNUX05VTEwoZXJy b3IpOworICAgICAgICBFWFBFQ1RfTk9UX05VTEwocmVzdWx0KTsKKyAgICAgICAgRVhQRUNUX05T X0VRVUFMKHJlc3VsdCwgZXZhbHVhdGlvblJlc3VsdC5nZXQoKSk7CisKKyAgICAgICAgcGVuZGlu Z0NhbGxiYWNrV2FzQ2FsbGVkID0gdHJ1ZTsKKyAgICB9XTsKKyAgICBUZXN0V2ViS2l0QVBJOjpV dGlsOjpydW4oJnBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCk7CisKKyAgICAvLyBVbnJlZ2lzdGVy IHRoZSB0ZXN0IGV4dGVuc2lvbi4KKyAgICBwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSBmYWxz ZTsKKyAgICBbW3dlYlZpZXcgX2luc3BlY3Rvcl0gdW5yZWdpc3RlckV4dGVuc2lvbjpzaGFyZWRJ bnNwZWN0b3JFeHRlbnNpb24uZ2V0KCkgY29tcGxldGlvbkhhbmRsZXI6XihOU0Vycm9yICogX051 bGxhYmxlIGVycm9yKSB7CisgICAgICAgIEVYUEVDVF9OVUxMKGVycm9yKTsKKworICAgICAgICBw ZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSB0cnVlOworICAgIH1dOworICAgIFRlc3RXZWJLaXRB UEk6OlV0aWw6OnJ1bigmcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkKTsKK30KKwogI2VuZGlmIC8v IEVOQUJMRShJTlNQRUNUT1JfRVhURU5TSU9OUykK 440514 2021-10-07 10:54:52 -0700 2021-10-07 11:38:20 -0700 Patch v1.2.1 (for landing) bug-230758-20211007105451.patch text/plain 19742 bburg U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzNjMwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkluc3BlY3RvclVJL0NoYW5nZUxvZwppbmRleCA4 MzBkODEyOTVmMWQ0ZjdkMzg0MjdjOTY5NTY5MmNhZjNhZjM1ODY4Li40YzY4NzY5YzU3NTEyMGJl YzQ5Nzc3ZjZmODBhNTI5NTljYzZmYjZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9y VUkvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKQEAgLTEs MyArMSw0NCBAQAorMjAyMS0xMC0wNSAgQkogQnVyZyAgPGJidXJnQGFwcGxlLmNvbT4KKworICAg ICAgICBXZWIgSW5zcGVjdG9yOiBXZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50VmlldyBz aG91bGQgbm90IHJlbG9hZCBpdHMgaWZyYW1lIHdoZW4gZGV0YWNoZWQKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzMDc1OAorICAgICAgICA8cmRhcjov Lzc0NzE0ODYxPgorCisgICAgICAgIFJldmlld2VkIGJ5IFRpbW90aHkgSGF0Y2hlci4KKworICAg ICAgICBXaGVuIGFuIDxpZnJhbWU+IGVsZW1lbnQgZGV0YWNoZXMgZnJvbSB0aGUgRE9NLCB0aGUg c2NyaXB0IGNvbnRleHQgaXMgZGVzdHJveWVkLCB3aGljaCB3ZSBkb24ndAorICAgICAgICB3YW50 IHRvIGhhcHBlbiBmb3IgX1dLSW5zcGVjdG9yRXh0ZW5zaW9uIHRhYnMuIEZpeCB0aGlzIGJ5IHRl YWNoaW5nIENvbnRlbnRWaWV3Q29udGFpbmVyIHRvCisgICAgICAgICdoaWRlJyBzdWNoIGNvbnRl bnQgdmlld3MgYnkgc2V0dGluZyBgZGlzcGxheTpub25lYCByYXRoZXIgdGhhbiBkZXRhY2hpbmcg ZnJvbSB0aGUgRE9NLgorCisgICAgICAgICogVXNlckludGVyZmFjZS9WaWV3cy9Db250ZW50Vmll d0NvbnRhaW5lci5qczoKKyAgICAgICAgKFdJLkNvbnRlbnRWaWV3Q29udGFpbmVyLnByb3RvdHlw ZS5fc2hvd0VudHJ5KToKKyAgICAgICAgKFdJLkNvbnRlbnRWaWV3Q29udGFpbmVyLnByb3RvdHlw ZS5faGlkZUVudHJ5KToKKyAgICAgICAgU2V0IGFuZCB1bnNldCAnZGlzcGxheTpub25lJyBpbnN0 ZWFkIG9mIGNhbGxpbmcgYWRkU3VidmlldygpIC8gcmVtb3ZlU3VidmlldygpLgorCisgICAgICAg ICogVXNlckludGVyZmFjZS9WaWV3cy9Db250ZW50Vmlld0NvbnRhaW5lci5jc3M6CisgICAgICAg ICguY29udGVudC12aWV3LWNvbnRhaW5lciA+IC5jb250ZW50LXZpZXcuaGlkZGVuLWZvci1kZXRh Y2gpOiBBZGRlZC4KKworICAgICAgICAoV0kuQ29udGVudFZpZXdDb250YWluZXIucHJvdG90eXBl Ll9kaXNhc3NvY2lhdGVGcm9tQ29udGVudFZpZXcpOgorICAgICAgICBDbGVhbiB1cCBhbnkgcmVt YWluaW5nIGNvbnRlbnQgdmlld3MgdGhhdCB3ZXJlIG5vdCBkZXRhY2hlZCBkdWUgdG8gb3ZlcnJp ZGluZyBzaG91bGROb3RSZW1vdmVGcm9tRE9NV2hlbkhpZGRlbi4KKworICAgICAgICAqIFVzZXJJ bnRlcmZhY2UvVmlld3MvQ29udGVudFZpZXcuanM6CisgICAgICAgIChXSS5Db250ZW50Vmlldy5w cm90b3R5cGUuZ2V0IHNob3VsZE5vdFJlbW92ZUZyb21ET01XaGVuSGlkZGVuKTogQWRkZWQuCisK KyAgICAgICAgKiBVc2VySW50ZXJmYWNlL1ZpZXdzL1dlYkluc3BlY3RvckV4dGVuc2lvblRhYkNv bnRlbnRWaWV3LmpzOgorICAgICAgICAoV0kuV2ViSW5zcGVjdG9yRXh0ZW5zaW9uVGFiQ29udGVu dFZpZXcpOgorICAgICAgICAoV0kuV2ViSW5zcGVjdG9yRXh0ZW5zaW9uVGFiQ29udGVudFZpZXcu cHJvdG90eXBlLmdldCBzaG91bGROb3RSZW1vdmVGcm9tRE9NV2hlbkhpZGRlbik6CisgICAgICAg IE92ZXJyaWRlIHRoaXMgdG8gb3B0IGludG8gdGhlIGFsdGVybmF0ZSBiZWhhdmlvciB0aGF0IGRv ZXMgbm90IGRldGFjaCBmcm9tIHRoZSBET00uIEl0IGlzIHN0aWxsCisgICAgICAgIG5lY2Vzc2Fy eSB0byBjYWxsIGF0dGFjaGVkKCkgYW5kIGRldGFjaGVkKCkgc28gdGhhdCBXZWJJbnBlY3RvckV4 dGVuc2lvblRhYkNvbnRlbnRWaWV3IGNhbiBnZW5lcmF0ZQorICAgICAgICBkaWRTaG93RXh0ZW5z aW9uVGFiL2RpZEhpZGVFeHRlbnNpb25UYWIgZXZlbnQgY2FsbGJhY2tzLgorCisgICAgICAgICog VXNlckludGVyZmFjZS9Db250cm9sbGVycy9XZWJJbnNwZWN0b3JFeHRlbnNpb25Db250cm9sbGVy LmpzOgorICAgICAgICAoV0kuV2ViSW5zcGVjdG9yRXh0ZW5zaW9uQ29udHJvbGxlci5wcm90b3R5 cGUuZ2V0IHJlZ2lzdGVyZWRFeHRlbnNpb25JRHMpOgorICAgICAgICAqIFVzZXJJbnRlcmZhY2Uv RGVidWcvQm9vdHN0cmFwLmpzOgorICAgICAgICAodXBkYXRlTW9ja1dlYkV4dGVuc2lvblRhYik6 CisgICAgICAgIChXSS5ydW5Cb290c3RyYXBPcGVyYXRpb25zKToKKyAgICAgICAgVGhpcyBpcyBh IGRyaXZlLWJ5IGZpeCB0byBhZGRyZXNzIGEgY29uc29sZSBhc3NlcnRpb24gc2VlbiB3aGlsZSBk ZXZlbG9waW5nIHRoZSBBUEkgdGVzdC4KKyAgICAgICAgRG9uJ3QgdW5yZWdpc3RlciB0aGUgbW9j ayBleHRlbnNpb24gaWYgaXQgaXMgbm90IHJlZ2lzdGVyZWQgaW4gdGhlIGZpcnN0IHBsYWNlLgor CiAyMDIxLTEwLTA1ICBQYXRyaWNrIEFuZ2xlICA8cGFuZ2xlQGFwcGxlLmNvbT4KIAogICAgICAg ICBXZWIgSW5zcGVjdG9yOiBTaG93IGNvbG9yIHNwYWNlIGZvciBjYW52YXNlcyBpbiB0aGUgR3Jh cGhpY3MgdGFiIG9uIHRoZSBvdmVydmlldyBjYXJkcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYklu c3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvQ29udHJvbGxlcnMvV2ViSW5zcGVjdG9yRXh0ZW5zaW9u Q29udHJvbGxlci5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL0NvbnRy b2xsZXJzL1dlYkluc3BlY3RvckV4dGVuc2lvbkNvbnRyb2xsZXIuanMKaW5kZXggNTc1YjQwODI3 YzUxN2QyYWFlNzU2NjlkMDI1ZTI5OWI4OTdjNThmMC4uZWFmMjY5OTJiMTE2NDZhMDExOGQ0ZWNh MjJhZWY3YzM3ODU1ZWQ3ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJ bnRlcmZhY2UvQ29udHJvbGxlcnMvV2ViSW5zcGVjdG9yRXh0ZW5zaW9uQ29udHJvbGxlci5qcwor KysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9Db250cm9sbGVycy9XZWJJ bnNwZWN0b3JFeHRlbnNpb25Db250cm9sbGVyLmpzCkBAIC0zNyw2ICszNywxMSBAQCBXSS5XZWJJ bnNwZWN0b3JFeHRlbnNpb25Db250cm9sbGVyID0gY2xhc3MgV2ViSW5zcGVjdG9yRXh0ZW5zaW9u Q29udHJvbGxlciBleHRlbgogCiAgICAgLy8gUHVibGljCiAKKyAgICBnZXQgcmVnaXN0ZXJlZEV4 dGVuc2lvbklEcygpCisgICAgeworICAgICAgICByZXR1cm4gbmV3IFNldCh0aGlzLl9leHRlbnNp b25Gb3JFeHRlbnNpb25JRE1hcC5rZXlzKCkpOworICAgIH0KKwogICAgIHJlZ2lzdGVyRXh0ZW5z aW9uKGV4dGVuc2lvbklELCBkaXNwbGF5TmFtZSkKICAgICB7CiAgICAgICAgIGlmICh0aGlzLl9l eHRlbnNpb25Gb3JFeHRlbnNpb25JRE1hcC5oYXMoZXh0ZW5zaW9uSUQpKSB7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9EZWJ1Zy9Cb290c3RyYXAuanMg Yi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9EZWJ1Zy9Cb290c3RyYXAuanMK aW5kZXggOGQ0NDAzNmViYTNjZGQ1YjBhZjU2MTkyNTQyYmQxZDU3NTVjOTYxNi4uYWQzMTVhNDFi YWM2YjM2YTJlZDdiY2VjMDIzZjMzYjdjYTAwNjQ2NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYklu c3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvRGVidWcvQm9vdHN0cmFwLmpzCisrKyBiL1NvdXJjZS9X ZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL0RlYnVnL0Jvb3RzdHJhcC5qcwpAQCAtMSw1ICsx LDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMTUgVW5pdmVyc2l0eSBvZiBXYXNoaW5ndG9u LgorICogQ29weXJpZ2h0IChDKSAyMDIxIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K ICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMTUwLDcgKzE1MSw5IEBAIFdJLnJ1 bkJvb3RzdHJhcE9wZXJhdGlvbnMgPSBmdW5jdGlvbigpIHsKIAogICAgICAgICAvLyBTaW11bGF0 ZXMgdGhlIHN0ZXBzIHRha2VuIGJ5IFdlYkluc3BlY3RvclVJRXh0ZW5zaW9uQ29udHJvbGxlciB0 byBjcmVhdGUgYW4gZXh0ZW5zaW9uIHRhYiBpbiBXZWJJbnNwZWN0b3JVSS4KICAgICAgICAgaWYg KCFXSS5zZXR0aW5ncy5lbmdpbmVlcmluZ1Nob3dNb2NrV2ViRXh0ZW5zaW9uVGFiLnZhbHVlKSB7 Ci0gICAgICAgICAgICBJbnNwZWN0b3JGcm9udGVuZEFQSS51bnJlZ2lzdGVyRXh0ZW5zaW9uKG1v Y2tEYXRhLmV4dGVuc2lvbklEKTsKKyAgICAgICAgICAgIGlmIChXSS5zaGFyZWRBcHAuZXh0ZW5z aW9uQ29udHJvbGxlci5yZWdpc3RlcmVkRXh0ZW5zaW9uSURzLmhhcyhtb2NrRGF0YS5leHRlbnNp b25JRCkpCisgICAgICAgICAgICAgICAgSW5zcGVjdG9yRnJvbnRlbmRBUEkudW5yZWdpc3RlckV4 dGVuc2lvbihtb2NrRGF0YS5leHRlbnNpb25JRCk7CisKICAgICAgICAgICAgIHJldHVybjsKICAg ICAgICAgfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFj ZS9WaWV3cy9Db250ZW50Vmlldy5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJm YWNlL1ZpZXdzL0NvbnRlbnRWaWV3LmpzCmluZGV4IDA1MzlhNWZlNDQxMDQzZTM4NTA3MzdjMmVh MTUwNDRlYWFmYTdjOGQuLmRjZjc0NDQ3OWRlOTNhMWI0ZDFkNGQ3ZmRlZWFjODEyYTAzYTJjNGEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0Nv bnRlbnRWaWV3LmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1Zp ZXdzL0NvbnRlbnRWaWV3LmpzCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykg MjAxMywgMjAxNSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQg KEMpIDIwMTMtMjAyMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTQyLDYgKzQyLDEzIEBAIFdJLkNvbnRlbnRWaWV3ID0g Y2xhc3MgQ29udGVudFZpZXcgZXh0ZW5kcyBXSS5WaWV3CiAKICAgICAvLyBTdGF0aWMKIAorICAg IHN0YXRpYyBzaG91bGROb3RSZW1vdmVGcm9tRE9NV2hlbkhpZGRlbigpCisgICAgeworICAgICAg ICAvLyBJbXBsZW1lbnRlZCBieSBzdWJjbGFzc2VzLgorICAgICAgICAvLyBSZXR1cm5zIHRydWUg aWYgdGhlIGNvbnRlbnQgdmlldyBzaG91bGQgKm5vdCogYmUgZGV0YWNoZWQgZnJvbSB0aGUgRE9N IHdoZW4gaGlkZGVuLgorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCiAgICAgc3RhdGlj IGNyZWF0ZUZyb21SZXByZXNlbnRlZE9iamVjdChyZXByZXNlbnRlZE9iamVjdCwgZXh0cmFBcmd1 bWVudHMpCiAgICAgewogICAgICAgICBjb25zb2xlLmFzc2VydChyZXByZXNlbnRlZE9iamVjdCk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9D b250ZW50Vmlld0NvbnRhaW5lci5jc3MgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVy ZmFjZS9WaWV3cy9Db250ZW50Vmlld0NvbnRhaW5lci5jc3MKaW5kZXggM2JlYWIxYThjNTUwMTkz ZThiMDU2NTE4ZTA2MmFjMmQ5NTYwNDhjMS4uYTQ0OGExNWEwNzRjMDNiMmYyM2U3NWQ5NmQ0YmYw NWZlMjc5NjdkMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZh Y2UvVmlld3MvQ29udGVudFZpZXdDb250YWluZXIuY3NzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0 b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL0NvbnRlbnRWaWV3Q29udGFpbmVyLmNzcwpAQCAtMSw1 ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTMgQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDEzLTIwMjEgQXBwbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0zNywzICsz Nyw3IEBACiAKICAgICBvdmVyZmxvdzogaGlkZGVuOwogfQorCisuY29udGVudC12aWV3LWNvbnRh aW5lciA+IC5jb250ZW50LXZpZXcuaGlkZGVuLXNpbXVsYXRpbmctZG9tLWRldGFjaGVkIHsKKyAg ICBkaXNwbGF5OiBub25lOworfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1Vz ZXJJbnRlcmZhY2UvVmlld3MvQ29udGVudFZpZXdDb250YWluZXIuanMgYi9Tb3VyY2UvV2ViSW5z cGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9Db250ZW50Vmlld0NvbnRhaW5lci5qcwppbmRl eCBhYjA1NmVmOTM1MjE1YWQwOTA0M2E4N2ZjOTc2MjBiYzdlODRmMDUwLi44MWQ5ZjgwYjc5ZDhh ZWZlYzQxMDUxMmViZjZiN2Y5NzZiYjcyNjVlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9Db250ZW50Vmlld0NvbnRhaW5lci5qcworKysgYi9T b3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9Db250ZW50Vmlld0NvbnRh aW5lci5qcwpAQCAtNDIxLDYgKzQyMSwxMSBAQCBXSS5Db250ZW50Vmlld0NvbnRhaW5lciA9IGNs YXNzIENvbnRlbnRWaWV3Q29udGFpbmVyIGV4dGVuZHMgV0kuVmlldwogICAgICAgICAgICAgcmV0 dXJuOwogICAgICAgICB9CiAKKyAgICAgICAgLy8gRGVzZWxlY3RlZCBleHRlbnNpb24gdGFicyBh cmUgc3RpbGwgYXR0YWNoZWQgdG8gdGhlIERPTSB2aWEgYHRoaXMuZWxlbWVudGAsCisgICAgICAg IC8vIHNvIHRoaXMgaXMgdGhlIGxhc3QgY2hhbmNlIHRvIGFjdHVhbGx5IHJlbW92ZSB0aGUgc3Vi dmlldyBhbmQgZGV0YWNoIGZyb20gdGhlIERPTS4KKyAgICAgICAgaWYgKGNvbnRlbnRWaWV3LmNv bnN0cnVjdG9yLnNob3VsZE5vdFJlbW92ZUZyb21ET01XaGVuSGlkZGVuKCkgJiYgY29udGVudFZp ZXcuaXNBdHRhY2hlZCkKKyAgICAgICAgICAgIHRoaXMucmVtb3ZlU3Vidmlldyhjb250ZW50Vmll dyk7CisKICAgICAgICAgY29uc29sZS5hc3NlcnQoIWNvbnRlbnRWaWV3LmlzQXR0YWNoZWQpOwog CiAgICAgICAgIGlmICghY29udGVudFZpZXcuX3BhcmVudENvbnRhaW5lcikKQEAgLTQ1Nyw2ICs0 NjIsMTAgQEAgV0kuQ29udGVudFZpZXdDb250YWluZXIgPSBjbGFzcyBDb250ZW50Vmlld0NvbnRh aW5lciBleHRlbmRzIFdJLlZpZXcKIAogICAgICAgICBpZiAoIXRoaXMuc3Vidmlld3MuaW5jbHVk ZXMoZW50cnkuY29udGVudFZpZXcpKQogICAgICAgICAgICAgdGhpcy5hZGRTdWJ2aWV3KGVudHJ5 LmNvbnRlbnRWaWV3KTsKKyAgICAgICAgZWxzZSBpZiAoZW50cnkuY29udGVudFZpZXcuY29uc3Ry dWN0b3Iuc2hvdWxkTm90UmVtb3ZlRnJvbURPTVdoZW5IaWRkZW4oKSkgeworICAgICAgICAgICAg ZW50cnkuY29udGVudFZpZXcuZWxlbWVudC5jbGFzc0xpc3QucmVtb3ZlKCJoaWRkZW4tc2ltdWxh dGluZy1kb20tZGV0YWNoZWQiKTsKKyAgICAgICAgICAgIGVudHJ5LmNvbnRlbnRWaWV3Ll9kaWRN b3ZlVG9QYXJlbnQodGhpcyk7CisgICAgICAgIH0KIAogICAgICAgICBlbnRyeS5wcmVwYXJlVG9T aG93KCk7CiAgICAgfQpAQCAtNDcxLDggKzQ4MCwxMyBAQCBXSS5Db250ZW50Vmlld0NvbnRhaW5l ciA9IGNsYXNzIENvbnRlbnRWaWV3Q29udGFpbmVyIGV4dGVuZHMgV0kuVmlldwogICAgICAgICAg ICAgcmV0dXJuOwogCiAgICAgICAgIGVudHJ5LnByZXBhcmVUb0hpZGUoKTsKLSAgICAgICAgaWYg KHRoaXMuc3Vidmlld3MuaW5jbHVkZXMoZW50cnkuY29udGVudFZpZXcpKQotICAgICAgICAgICAg dGhpcy5yZW1vdmVTdWJ2aWV3KGVudHJ5LmNvbnRlbnRWaWV3KTsKKyAgICAgICAgaWYgKHRoaXMu c3Vidmlld3MuaW5jbHVkZXMoZW50cnkuY29udGVudFZpZXcpKSB7CisgICAgICAgICAgICBpZiAo ZW50cnkuY29udGVudFZpZXcuY29uc3RydWN0b3Iuc2hvdWxkTm90UmVtb3ZlRnJvbURPTVdoZW5I aWRkZW4oKSkgeworICAgICAgICAgICAgICAgIGVudHJ5LmNvbnRlbnRWaWV3LmVsZW1lbnQuY2xh c3NMaXN0LmFkZCgiaGlkZGVuLXNpbXVsYXRpbmctZG9tLWRldGFjaGVkIik7CisgICAgICAgICAg ICAgICAgZW50cnkuY29udGVudFZpZXcuX2RpZE1vdmVUb1BhcmVudChudWxsKTsKKyAgICAgICAg ICAgIH0gZWxzZQorICAgICAgICAgICAgICAgIHRoaXMucmVtb3ZlU3VidmlldyhlbnRyeS5jb250 ZW50Vmlldyk7CisgICAgICAgIH0KICAgICB9CiAKICAgICBfdG9tYnN0b25lQ29udGVudFZpZXdD b250YWluZXJzRm9yQ29udGVudFZpZXcoY29udGVudFZpZXcpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9UYWJCcm93c2VyLmpzIGIvU291cmNl L1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvVmlld3MvVGFiQnJvd3Nlci5qcwppbmRleCBh ZWEyNTJiMTZmYzJiMWQ5ZTU1ZjQxY2QzMzg2NzViNzI0MDlmYzVhLi44MDRkM2JiZjEzYTM3MTg5 YzNiYzI0NTI1MTE5ZGJjMDFmOTA0NDEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9y VUkvVXNlckludGVyZmFjZS9WaWV3cy9UYWJCcm93c2VyLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNw ZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1ZpZXdzL1RhYkJyb3dzZXIuanMKQEAgLTE3MSw3ICsxNzEs OSBAQCBXSS5UYWJCcm93c2VyID0gY2xhc3MgVGFiQnJvd3NlciBleHRlbmRzIFdJLlZpZXcKICAg ICAgICAgICAgIHRoaXMuX3RhYkJhci5hZGRUYWJCYXJJdGVtKHRhYkJhckl0ZW0sIG9wdGlvbnMp OwogCiAgICAgICAgIGNvbnNvbGUuYXNzZXJ0KHRoaXMuX3JlY2VudFRhYkNvbnRlbnRWaWV3cy5s ZW5ndGggPT09IHRoaXMuX3RhYkJhci50YWJDb3VudCk7Ci0gICAgICAgIGNvbnNvbGUuYXNzZXJ0 KCF0aGlzLnNlbGVjdGVkVGFiQ29udGVudFZpZXcgfHwgdGhpcy5zZWxlY3RlZFRhYkNvbnRlbnRW aWV3ID09PSB0aGlzLl9yZWNlbnRUYWJDb250ZW50Vmlld3NbMF0pOworCisgICAgICAgIGxldCBz aG91bGRTYXZlVGFiID0gdGhpcy5zZWxlY3RlZFRhYkNvbnRlbnRWaWV3Py5jb25zdHJ1Y3Rvci5z aG91bGRTYXZlVGFiKCkgfHwgdGhpcy5zZWxlY3RlZFRhYkNvbnRlbnRWaWV3Py5jb25zdHJ1Y3Rv ci5zaG91bGRQaW5UYWIoKTsKKyAgICAgICAgY29uc29sZS5hc3NlcnQoIXRoaXMuc2VsZWN0ZWRU YWJDb250ZW50VmlldyB8fCB0aGlzLnNlbGVjdGVkVGFiQ29udGVudFZpZXcgPT09IHRoaXMuX3Jl Y2VudFRhYkNvbnRlbnRWaWV3c1swXSB8fCAhc2hvdWxkU2F2ZVRhYik7CiAKICAgICAgICAgcmV0 dXJuIHRydWU7CiAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJ bnRlcmZhY2UvVmlld3MvV2ViSW5zcGVjdG9yRXh0ZW5zaW9uVGFiQ29udGVudFZpZXcuanMgYi9T b3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9XZWJJbnNwZWN0b3JFeHRl bnNpb25UYWJDb250ZW50Vmlldy5qcwppbmRleCA3NGFmYTRjY2ZiZDI4Y2Y2MzRiMTg3MzQ4ZDA2 NTcwYjZlYmUyMGFlLi4zNjc2NGFiMmVkNWM2ZDM2ZWFhZWIyZWY2ZjExMmFlZjY0ZTMzYTJiIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9XZWJJ bnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50Vmlldy5qcworKysgYi9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvVXNlckludGVyZmFjZS9WaWV3cy9XZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50 Vmlldy5qcwpAQCAtNDAsOSArNDAsNiBAQCBXSS5XZWJJbnNwZWN0b3JFeHRlbnNpb25UYWJDb250 ZW50VmlldyA9IGNsYXNzIFdlYkluc3BlY3RvckV4dGVuc2lvblRhYkNvbnRlbnRWaQogICAgICAg ICB0aGlzLl90YWJJbmZvID0gdGFiSW5mbzsKICAgICAgICAgdGhpcy5fc291cmNlVVJMID0gc291 cmNlVVJMOwogCi0gICAgICAgIC8vIEZJWE1FOiB0aGUgPGlmcmFtZT4ncyBkb2N1bWVudCBpcyBp bXBsaWNpdGx5IHJlbG9hZGVkIHdoZW4gdGhpcwotICAgICAgICAvLyBjb250ZW50IHZpZXcncyBl bGVtZW50IGlzIGRldGFjaGVkIGFuZCBsYXRlciByZS1hdHRhY2hlZCB0byB0aGUgRE9NLgotICAg ICAgICAvLyBUaGlzIGlzIGEgYnVnIGFuZCB3aWxsIGJlIGFkZHJlc3NlZCBpbiA8aHR0cHM6Ly93 ZWJraXQub3JnL2IvMjMwNzU4Pi4KICAgICAgICAgdGhpcy5faWZyYW1lRWxlbWVudCA9IHRoaXMu ZWxlbWVudC5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJpZnJhbWUiKSk7CiAg ICAgICAgIHRoaXMuX2lmcmFtZUVsZW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigibG9hZCIsIHRoaXMu X2V4dGVuc2lvbkZyYW1lRGlkTG9hZC5iaW5kKHRoaXMpKTsKICAgICAgICAgdGhpcy5faWZyYW1l RWxlbWVudC5zcmMgPSB0aGlzLl9zb3VyY2VVUkw7CkBAIC04Nyw2ICs4NCwxMSBAQCBXSS5XZWJJ bnNwZWN0b3JFeHRlbnNpb25UYWJDb250ZW50VmlldyA9IGNsYXNzIFdlYkluc3BlY3RvckV4dGVu c2lvblRhYkNvbnRlbnRWaQogCiAgICAgc3RhdGljIHNob3VsZFNhdmVUYWIoKSB7IHJldHVybiBm YWxzZTsgfQogCisgICAgc3RhdGljIHNob3VsZE5vdFJlbW92ZUZyb21ET01XaGVuSGlkZGVuKCkg eworICAgICAgICAvLyBUaGlzIGlzIG5lY2Vzc2FyeSB0byBhdm9pZCB0aGUgPGlmcmFtZT4gY29u dGVudCBmcm9tIGJlaW5nIHJlbG9hZGVkIHdoZW4gdGhlIGV4dGVuc2lvbiB0YWIgaXMgaGlkZGVu LgorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKICAgICAvLyBQcml2YXRlCiAKICAgICBf ZXh0ZW5zaW9uRnJhbWVEaWRMb2FkKCkKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rv b2xzL0NoYW5nZUxvZwppbmRleCBkN2QxZmRjNTg5MzljYTU3MDVlMTdmOGY5MjgzZTUwMjk3NWJm NjM5Li45MGRhZWY0MjMyOTZkNzAzNzBiNjhjZTA4YTU4NzI3N2NmZjhlMzMzIDEwMDY0NAotLS0g YS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAK KzIwMjEtMTAtMDUgIEJKIEJ1cmcgIDxiYnVyZ0BhcHBsZS5jb20+CisKKyAgICAgICAgV2ViIElu c3BlY3RvcjogV2ViSW5zcGVjdG9yRXh0ZW5zaW9uVGFiQ29udGVudFZpZXcgc2hvdWxkIG5vdCBy ZWxvYWQgaXRzIGlmcmFtZSB3aGVuIGRldGFjaGVkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzA3NTgKKyAgICAgICAgPHJkYXI6Ly83NDcxNDg2MT4K KworICAgICAgICBSZXZpZXdlZCBieSBUaW1vdGh5IEhhdGNoZXIuCisKKyAgICAgICAgQWRkIGEg bmV3IHRlc3QgdG8gdmVyaWZ5IHRoYXQgcmUtc2VsZWN0aW5nIGFuIGV4dGVuc2lvbiB0YWIgZG9l cyBub3QgY2F1c2UgaXQgdG8gcmVsb2FkLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJLaXRDb2NvYS9JbnNwZWN0b3JFeHRlbnNpb24tYmFzaWMtdGFiLmh0bWw6CisgICAgICAg ICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9XS0luc3BlY3RvckV4dGVuc2lvbi5t bToKKyAgICAgICAgKFRFU1QpOgorCiAyMDIxLTEwLTA2ICBQaGlsaXAgQ2hpbWVudG8gIDxwY2hp bWVudG9AaWdhbGlhLmNvbT4KIAogICAgICAgICBTdHlsZSBjaGVja2VyIHNob3VsZCBjaGVjayBz cGFjaW5nIGluc2lkZSBicmFjZXMgd2l0aCBlbGVtZW50cyBpbiB0aGVtCmRpZmYgLS1naXQgYS9U b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL0luc3BlY3RvckV4dGVuc2lvbi1i YXNpYy10YWIuaHRtbCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvSW5z cGVjdG9yRXh0ZW5zaW9uLWJhc2ljLXRhYi5odG1sCmluZGV4IDQyYmYxOWQwYjI3NzU0MjE5YzUy MmQ3YTNhZDA4YTI5YzRhNWEwZTQuLjZmYWE5ZmI0MGY2MDUxNGZlZmMzZWFlNGMxM2VjZjdmYjRj MmIxZjAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2Ev SW5zcGVjdG9yRXh0ZW5zaW9uLWJhc2ljLXRhYi5odG1sCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViS2l0Q29jb2EvSW5zcGVjdG9yRXh0ZW5zaW9uLWJhc2ljLXRhYi5odG1sCkBA IC0xLDEwICsxLDI0IEBACiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KKyAgICAvLyBVc2VkIGJ5 IFdLSW5zcGVjdG9yRXh0ZW5zaW9uLkNhbkV2YWx1YXRlU2NyaXB0SW5FeHRlbnNpb25UYWIKICAg ICB3aW5kb3cuX3NlY3JldFZhbHVlID0ge2Fuc3dlcjo0Mn07CisKKyAgICAvLyBVc2VkIGJ5IFdL SW5zcGVjdG9yRXh0ZW5zaW9uLkV4dGVuc2lvblRhYklzUGVyc2lzdGVudAorICAgIHdpbmRvdy5n ZXRVbmlxdWVWYWx1ZSA9IGZ1bmN0aW9uKCkgeworICAgICAgICBpZiAoIXdpbmRvdy5fY2FjaGVk VW5pcXVlVmFsdWUpIHsKKyAgICAgICAgICAgIHdpbmRvdy5fY2FjaGVkVW5pcXVlVmFsdWUgPSBN YXRoLmZsb29yKE1hdGgucmFuZG9tKCkgKiAxMGU5KTsKKyAgICAgICAgICAgIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJ1bmlxdWVWYWx1ZUZpZWxkIikuaW5uZXJUZXh0ID0gd2luZG93Ll9jYWNo ZWRVbmlxdWVWYWx1ZTsKKyAgICAgICAgfQorCisgICAgICAgIHJldHVybiB3aW5kb3cuX2NhY2hl ZFVuaXF1ZVZhbHVlOworICAgIH0KIDwvc2NyaXB0PgogPGJvZHk+CiA8aDE+VGhpcyBpcyBhIHRl c3QgZXh0ZW5zaW9uLjwvaDE+CiA8cD5JbiBhIG5vcm1hbCBleHRlbnNpb24sIHRoaXMgYXJlYSB3 b3VsZCBzaG93IHRoZSBleHRlbnNpb24ncyB1c2VyIGludGVyZmFjZS48L3A+Cis8cD5UaGUgdW5p cXVlIHZhbHVlIGZvciB0aGlzIGlmcmFtZSdzIGV4ZWN1dGlvbiBjb250ZXh0IGlzOgorICAgIDxz cGFuIGlkPSJ1bmlxdWVWYWx1ZUZpZWxkIj5UQkQ8L3NwYW4+Cis8L3A+CiA8L2JvZHk+CiA8L2h0 bWw+CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1dL SW5zcGVjdG9yRXh0ZW5zaW9uLm1tIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRD b2NvYS9XS0luc3BlY3RvckV4dGVuc2lvbi5tbQppbmRleCAyNDIxNzI4OGM5Y2ZjMTBmOTc1YmM3 NzhiMTg0NTI2MDcwNGU5MzlmLi5hNjQwNDQzZjRlYjM5MWJlM2IwYzE0ZjRmNDJhMWJiNTg0M2Vh MzFhIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1dL SW5zcGVjdG9yRXh0ZW5zaW9uLm1tCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2Vi S2l0Q29jb2EvV0tJbnNwZWN0b3JFeHRlbnNpb24ubW0KQEAgLTQ3LDYgKzQ3LDcgQEAgc3RhdGlj IGJvb2wgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gZmFsc2U7CiBzdGF0aWMgUmV0YWluUHRy PFRlc3RJbnNwZWN0b3JVUkxTY2hlbWVIYW5kbGVyPiBzaGFyZWRVUkxTY2hlbWVIYW5kbGVyOwog c3RhdGljIFJldGFpblB0cjxfV0tJbnNwZWN0b3JFeHRlbnNpb24+IHNoYXJlZEluc3BlY3RvckV4 dGVuc2lvbjsKIHN0YXRpYyBSZXRhaW5QdHI8TlNTdHJpbmc+IHNoYXJlZEV4dGVuc2lvblRhYklk ZW50aWZpZXI7CitzdGF0aWMgUmV0YWluUHRyPE5TT2JqZWN0PiBldmFsdWF0aW9uUmVzdWx0Owog CiBzdGF0aWMgdm9pZCByZXNldEdsb2JhbFN0YXRlKCkKIHsKQEAgLTE4OCw0ICsxODksMTIxIEBA IFRFU1QoV0tJbnNwZWN0b3JFeHRlbnNpb24sIENhbkV2YWx1YXRlU2NyaXB0SW5FeHRlbnNpb25U YWIpCiAgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZwZW5kaW5nQ2FsbGJhY2tXYXNDYWxs ZWQpOwogfQogCitURVNUKFdLSW5zcGVjdG9yRXh0ZW5zaW9uLCBFeHRlbnNpb25UYWJJc1BlcnNp c3RlbnQpCit7CisgICAgcmVzZXRHbG9iYWxTdGF0ZSgpOworCisgICAgYXV0byB3ZWJWaWV3Q29u ZmlndXJhdGlvbiA9IGFkb3B0TlMoW1dLV2ViVmlld0NvbmZpZ3VyYXRpb24gbmV3XSk7CisgICAg d2ViVmlld0NvbmZpZ3VyYXRpb24uZ2V0KCkucHJlZmVyZW5jZXMuX2RldmVsb3BlckV4dHJhc0Vu YWJsZWQgPSBZRVM7CisgICAgYXV0byB3ZWJWaWV3ID0gYWRvcHROUyhbW1dLV2ViVmlldyBhbGxv Y10gaW5pdFdpdGhGcmFtZTpDR1JlY3RNYWtlKDAsIDAsIDgwMCwgNjAwKSBjb25maWd1cmF0aW9u OndlYlZpZXdDb25maWd1cmF0aW9uLmdldCgpXSk7CisgICAgYXV0byB1aURlbGVnYXRlID0gYWRv cHROUyhbVUlEZWxlZ2F0ZUZvclRlc3RpbmdJbnNwZWN0b3JFeHRlbnNpb24gbmV3XSk7CisKKyAg ICBbd2ViVmlldyBzZXRVSURlbGVnYXRlOnVpRGVsZWdhdGUuZ2V0KCldOworICAgIFt3ZWJWaWV3 IGxvYWRIVE1MU3RyaW5nOkAiPGhlYWQ+PHRpdGxlPlRlc3QgcGFnZSB0byBiZSBpbnNwZWN0ZWQ8 L3RpdGxlPjwvaGVhZD48Ym9keT48cD5GaWxsZXIgY29udGVudDwvcD48L2JvZHk+IiBiYXNlVVJM OltOU1VSTCBVUkxXaXRoU3RyaW5nOkAiaHR0cDovL2V4YW1wbGUuY29tLyJdXTsKKworICAgIFtb d2ViVmlldyBfaW5zcGVjdG9yXSBzaG93XTsKKyAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4o JmRpZEF0dGFjaExvY2FsSW5zcGVjdG9yQ2FsbGVkKTsKKworICAgIGF1dG8gZXh0ZW5zaW9uSUQg PSBbTlNVVUlEIFVVSURdLlVVSURTdHJpbmc7CisgICAgYXV0byBleHRlbnNpb25EaXNwbGF5TmFt ZSA9IEAiU2Vjb25kRXh0ZW5zaW9uIjsKKworICAgIC8vIFJlZ2lzdGVyIHRoZSB0ZXN0IGV4dGVu c2lvbi4KKyAgICBwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSBmYWxzZTsKKyAgICBbW3dlYlZp ZXcgX2luc3BlY3Rvcl0gcmVnaXN0ZXJFeHRlbnNpb25XaXRoSUQ6ZXh0ZW5zaW9uSUQgZGlzcGxh eU5hbWU6ZXh0ZW5zaW9uRGlzcGxheU5hbWUgY29tcGxldGlvbkhhbmRsZXI6XihOU0Vycm9yICog X051bGxhYmxlIGVycm9yLCBfV0tJbnNwZWN0b3JFeHRlbnNpb24gKiBfTnVsbGFibGUgZXh0ZW5z aW9uKSB7CisgICAgICAgIEVYUEVDVF9OVUxMKGVycm9yKTsKKyAgICAgICAgRVhQRUNUX05PVF9O VUxMKGV4dGVuc2lvbik7CisgICAgICAgIHNoYXJlZEluc3BlY3RvckV4dGVuc2lvbiA9IGV4dGVu c2lvbjsKKworICAgICAgICBwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSB0cnVlOworICAgIH1d OworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVk KTsKKworICAgIGF1dG8gZXh0ZW5zaW9uRGVsZWdhdGUgPSBhZG9wdE5TKFtJbnNwZWN0b3JFeHRl bnNpb25EZWxlZ2F0ZUZvclRlc3RpbmdJbnNwZWN0b3JFeHRlbnNpb24gbmV3XSk7CisgICAgW3No YXJlZEluc3BlY3RvckV4dGVuc2lvbiBzZXREZWxlZ2F0ZTpleHRlbnNpb25EZWxlZ2F0ZS5nZXQo KV07CisKKyAgICAvLyBDcmVhdGUgYW5kIHNob3cgYW4gZXh0ZW5zaW9uIHRhYi4KKyAgICBhdXRv IGljb25VUkwgPSBbTlNVUkwgVVJMV2l0aFN0cmluZzpAInRlc3QtcmVzb3VyY2U6Ly9TZWNvbmRF eHRlbnNpb24vSW5zcGVjdG9yRXh0ZW5zaW9uLVRhYkljb24tMzB4MzAucG5nIl07CisgICAgYXV0 byBzb3VyY2VVUkwgPSBbTlNVUkwgVVJMV2l0aFN0cmluZzpAInRlc3QtcmVzb3VyY2U6Ly9TZWNv bmRFeHRlbnNpb24vSW5zcGVjdG9yRXh0ZW5zaW9uLWJhc2ljLXRhYi5odG1sIl07CisKKyAgICBw ZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSBmYWxzZTsKKyAgICBbc2hhcmVkSW5zcGVjdG9yRXh0 ZW5zaW9uIGNyZWF0ZVRhYldpdGhOYW1lOkAiU2Vjb25kRXh0ZW5zaW9uLVRhYiIgdGFiSWNvblVS TDppY29uVVJMIHNvdXJjZVVSTDpzb3VyY2VVUkwgY29tcGxldGlvbkhhbmRsZXI6XihOU0Vycm9y ICogX051bGxhYmxlIGVycm9yLCBOU1N0cmluZyAqIF9OdWxsYWJsZSBleHRlbnNpb25UYWJJZGVu dGlmaWVyKSB7CisgICAgICAgIEVYUEVDVF9OVUxMKGVycm9yKTsKKyAgICAgICAgRVhQRUNUX05P VF9OVUxMKGV4dGVuc2lvblRhYklkZW50aWZpZXIpOworICAgICAgICBzaGFyZWRFeHRlbnNpb25U YWJJZGVudGlmaWVyID0gZXh0ZW5zaW9uVGFiSWRlbnRpZmllcjsKKworICAgICAgICBwZW5kaW5n Q2FsbGJhY2tXYXNDYWxsZWQgPSB0cnVlOworICAgIH1dOworICAgIFRlc3RXZWJLaXRBUEk6OlV0 aWw6OnJ1bigmcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkKTsKKworICAgIHBlbmRpbmdDYWxsYmFj a1dhc0NhbGxlZCA9IGZhbHNlOworICAgIGRpZFNob3dFeHRlbnNpb25UYWJXYXNDYWxsZWQgPSBm YWxzZTsKKyAgICBbW3dlYlZpZXcgX2luc3BlY3Rvcl0gc2hvd0V4dGVuc2lvblRhYldpdGhJZGVu dGlmaWVyOnNoYXJlZEV4dGVuc2lvblRhYklkZW50aWZpZXIuZ2V0KCkgY29tcGxldGlvbkhhbmRs ZXI6XihOU0Vycm9yICogX051bGxhYmxlIGVycm9yKSB7CisgICAgICAgIEVYUEVDVF9OVUxMKGVy cm9yKTsKKworICAgICAgICBwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSB0cnVlOworICAgIH1d OworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVk KTsKKyAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJmRpZFNob3dFeHRlbnNpb25UYWJXYXND YWxsZWQpOworCisgICAgYXV0byBzY3JpcHRTb3VyY2UgPSBAIiEhd2luZG93LmdldFVuaXF1ZVZh bHVlICYmIHdpbmRvdy5nZXRVbmlxdWVWYWx1ZSgpIjsKKworICAgIC8vIFJlYWQgYmFjayBhIHZh bHVlIHRoYXQgaXMgdW5pcXVlIHRvIHRoZSA8aWZyYW1lPidzIHNjcmlwdCBjb250ZXh0LgorICAg IHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IGZhbHNlOworICAgIFtzaGFyZWRJbnNwZWN0b3JF eHRlbnNpb24gX2V2YWx1YXRlU2NyaXB0OnNjcmlwdFNvdXJjZSBpbkV4dGVuc2lvblRhYldpdGhJ ZGVudGlmaWVyOnNoYXJlZEV4dGVuc2lvblRhYklkZW50aWZpZXIuZ2V0KCkgY29tcGxldGlvbkhh bmRsZXI6XihOU0Vycm9yICogX051bGxhYmxlIGVycm9yLCBOU0RpY3Rpb25hcnkgKiBfTnVsbGFi bGUgcmVzdWx0KSB7CisgICAgICAgIEVYUEVDVF9OVUxMKGVycm9yKTsKKyAgICAgICAgRVhQRUNU X05PVF9OVUxMKHJlc3VsdCk7CisgICAgICAgIGV2YWx1YXRpb25SZXN1bHQgPSByZXN1bHQ7CisK KyAgICAgICAgcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkID0gdHJ1ZTsKKyAgICB9XTsKKyAgICBU ZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJnBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCk7CisKKyAg ICAvLyBDYXVzZSB0aGUgZXh0ZW5zaW9uIHRhYiB0byBiZSBoaWRkZW4uIEl0cyA8aWZyYW1lPiBz aG91bGQgbm90IGRldGFjaCBmcm9tIHRoZSBET00uCisgICAgW1t3ZWJWaWV3IF9pbnNwZWN0b3Jd IHNob3dDb25zb2xlXTsKKyAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJmRpZEhpZGVFeHRl bnNpb25UYWJXYXNDYWxsZWQpOworCisgICAgLy8gQ2hlY2sgdGhlIHVuaXF1ZSB2YWx1ZSBhZ2Fp biwgd2hpbGUgdGhlIDxpZnJhbWU+IGlzIGJlaW5nIGhpZGRlbi4gSWYgdGhlIDxpZnJhbWU+IGlz CisgICAgLy8gZGV0YWNoZWQgZnJvbSB0aGUgRE9NLCB0aGVuIHRoaXMgZXZhbHVhdGlvbiB3aWxs IGZhaWwgb3IgaGFuZy4KKyAgICBwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSBmYWxzZTsKKyAg ICBbc2hhcmVkSW5zcGVjdG9yRXh0ZW5zaW9uIF9ldmFsdWF0ZVNjcmlwdDpzY3JpcHRTb3VyY2Ug aW5FeHRlbnNpb25UYWJXaXRoSWRlbnRpZmllcjpzaGFyZWRFeHRlbnNpb25UYWJJZGVudGlmaWVy LmdldCgpIGNvbXBsZXRpb25IYW5kbGVyOl4oTlNFcnJvciAqIF9OdWxsYWJsZSBlcnJvciwgTlNE aWN0aW9uYXJ5ICogX051bGxhYmxlIHJlc3VsdCkgeworICAgICAgICBFWFBFQ1RfTlVMTChlcnJv cik7CisgICAgICAgIEVYUEVDVF9OT1RfTlVMTChyZXN1bHQpOworICAgICAgICBFWFBFQ1RfTlNf RVFVQUwocmVzdWx0LCBldmFsdWF0aW9uUmVzdWx0LmdldCgpKTsKKworICAgICAgICBwZW5kaW5n Q2FsbGJhY2tXYXNDYWxsZWQgPSB0cnVlOworICAgIH1dOworICAgIFRlc3RXZWJLaXRBUEk6OlV0 aWw6OnJ1bigmcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkKTsKKworICAgIC8vIFJlc2VsZWN0IHRo ZSBleHRlbnNpb24gdGFiLgorICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IGZhbHNlOwor ICAgIGRpZFNob3dFeHRlbnNpb25UYWJXYXNDYWxsZWQgPSBmYWxzZTsKKyAgICBbW3dlYlZpZXcg X2luc3BlY3Rvcl0gc2hvd0V4dGVuc2lvblRhYldpdGhJZGVudGlmaWVyOnNoYXJlZEV4dGVuc2lv blRhYklkZW50aWZpZXIuZ2V0KCkgY29tcGxldGlvbkhhbmRsZXI6XihOU0Vycm9yICogX051bGxh YmxlIGVycm9yKSB7CisgICAgICAgIEVYUEVDVF9OVUxMKGVycm9yKTsKKworICAgICAgICBwZW5k aW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSB0cnVlOworICAgIH1dOworICAgIFRlc3RXZWJLaXRBUEk6 OlV0aWw6OnJ1bigmcGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkKTsKKyAgICBUZXN0V2ViS2l0QVBJ OjpVdGlsOjpydW4oJmRpZFNob3dFeHRlbnNpb25UYWJXYXNDYWxsZWQpOworCisgICAgLy8gQ2hl Y2sgdGhlIHVuaXF1ZSB2YWx1ZSBhZ2FpbiBhZnRlciByZXNlbGVjdGluZyB0aGUgZXh0ZW5zaW9u IHRhYi4KKyAgICBwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQgPSBmYWxzZTsKKyAgICBbc2hhcmVk SW5zcGVjdG9yRXh0ZW5zaW9uIF9ldmFsdWF0ZVNjcmlwdDpzY3JpcHRTb3VyY2UgaW5FeHRlbnNp b25UYWJXaXRoSWRlbnRpZmllcjpzaGFyZWRFeHRlbnNpb25UYWJJZGVudGlmaWVyLmdldCgpIGNv bXBsZXRpb25IYW5kbGVyOl4oTlNFcnJvciAqIF9OdWxsYWJsZSBlcnJvciwgTlNEaWN0aW9uYXJ5 ICogX051bGxhYmxlIHJlc3VsdCkgeworICAgICAgICBFWFBFQ1RfTlVMTChlcnJvcik7CisgICAg ICAgIEVYUEVDVF9OT1RfTlVMTChyZXN1bHQpOworICAgICAgICBFWFBFQ1RfTlNfRVFVQUwocmVz dWx0LCBldmFsdWF0aW9uUmVzdWx0LmdldCgpKTsKKworICAgICAgICBwZW5kaW5nQ2FsbGJhY2tX YXNDYWxsZWQgPSB0cnVlOworICAgIH1dOworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigm cGVuZGluZ0NhbGxiYWNrV2FzQ2FsbGVkKTsKKworICAgIC8vIFVucmVnaXN0ZXIgdGhlIHRlc3Qg ZXh0ZW5zaW9uLgorICAgIHBlbmRpbmdDYWxsYmFja1dhc0NhbGxlZCA9IGZhbHNlOworICAgIFtb d2ViVmlldyBfaW5zcGVjdG9yXSB1bnJlZ2lzdGVyRXh0ZW5zaW9uOnNoYXJlZEluc3BlY3RvckV4 dGVuc2lvbi5nZXQoKSBjb21wbGV0aW9uSGFuZGxlcjpeKE5TRXJyb3IgKiBfTnVsbGFibGUgZXJy b3IpIHsKKyAgICAgICAgRVhQRUNUX05VTEwoZXJyb3IpOworCisgICAgICAgIHBlbmRpbmdDYWxs YmFja1dhc0NhbGxlZCA9IHRydWU7CisgICAgfV07CisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6 cnVuKCZwZW5kaW5nQ2FsbGJhY2tXYXNDYWxsZWQpOworfQorCiAjZW5kaWYgLy8gRU5BQkxFKElO U1BFQ1RPUl9FWFRFTlNJT05TKQo=