181472 2018-01-10 02:14:05 -0800 [WPE] TestWebKitFindController asserts 2018-01-23 09:19:48 -0800 1 1 1 Unclassified WebKit WPE WebKit WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 Ms2ger mcatanzaro berto bugs-noreply cgarcia ews-watchlist gustavo mcatanzaro oldest_to_newest 1387583 0 Ms2ger 2018-01-10 02:14:05 -0800 In the _WebKitWebViewPrivate destructor, we set this->view to nullptr. We then automatically destruct this->findController, and end up calling webkitFindControllerDispose, which calls webkitWebViewGetPage()... But that asserts webView->priv->view is non-null. 1387759 1 mcatanzaro 2018-01-10 11:26:25 -0800 Carlos Garcia, do you remember why WKWPE::View has to be destroyed before webkitWebViewBackendUnref? That's not helping things. 1387761 2 330935 mcatanzaro 2018-01-10 11:27:04 -0800 Created attachment 330935 Patch 1387762 3 ews-watchlist 2018-01-10 11:28:34 -0800 Thanks for the patch. If this patch contains new public API please make sure it follows the guidelines for new WebKit2 GTK+ API. See http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API 1388142 4 330935 cgarcia 2018-01-10 23:31:30 -0800 Comment on attachment 330935 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=330935&action=review > Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp:202 > + findController = nullptr; I'm not sure this is the right fix. Objects keeping a pointer to the view and not taking a reference should use g_object_add_weak_pointer() like WebKitDownload does. 1388256 5 mcatanzaro 2018-01-11 09:18:52 -0800 Good idea, that's safer. (At least, it's safer as long as we do it right... I dislike that GObject weak pointers cause random un-debuggable memory corruption when misused.) 1388261 6 mcatanzaro 2018-01-11 09:30:29 -0800 (In reply to Michael Catanzaro from comment #5) > Good idea, that's safer. No wait, it's not a great idea. WebKitWebView holds a ref on the WebKitFindController, so there's no reason for WebKitFindController to need a weak pointer. WebKitWebView should be valid for its entire lifetime. It's simpler to just fix the order of destruction. The objects are ordered properly in _WebKitWebViewPrivate to ensure that the WebKitFindController is destroyed before the WKWPE::View, but that is broken by manually destroying the WKWPE::View before calling webkitWebViewBackendUnref. WebKitDownload is a very different case, because WebKitDownload is not owned by the WebKitWebView and indeed regularly outlives its associated WebKitWebView. 1388288 7 331068 mcatanzaro 2018-01-11 10:23:25 -0800 Created attachment 331068 Patch 1388289 8 mcatanzaro 2018-01-11 10:24:39 -0800 (In reply to Michael Catanzaro from comment #7) > Created attachment 331068 [details] > Patch Alternative approach using a GRefPtr. Not sure where the best place to declare the overloads is. 1388702 9 cgarcia 2018-01-11 22:28:03 -0800 (In reply to Michael Catanzaro from comment #6) > (In reply to Michael Catanzaro from comment #5) > > Good idea, that's safer. > > No wait, it's not a great idea. WebKitWebView holds a ref on the > WebKitFindController, so there's no reason for WebKitFindController to need > a weak pointer. WebKitWebView should be valid for its entire lifetime. You are right. > It's > simpler to just fix the order of destruction. > > The objects are ordered properly in _WebKitWebViewPrivate to ensure that the > WebKitFindController is destroyed before the WKWPE::View, but that is broken > by manually destroying the WKWPE::View before calling > webkitWebViewBackendUnref. > > WebKitDownload is a very different case, because WebKitDownload is not owned > by the WebKitWebView and indeed regularly outlives its associated > WebKitWebView. Indeed, I agree. 1388705 10 cgarcia 2018-01-11 22:38:51 -0800 (In reply to Michael Catanzaro from comment #1) > Carlos Garcia, do you remember why WKWPE::View has to be destroyed before > webkitWebViewBackendUnref? That's not helping things. Because the wpe backend is only owned by WebKitWebViewBackend, and WKView maintains a pointer to the wpe backend. We don't want to handle the case of wpe backend being nullptr in WKView or adding a way to notify WKView when wpe backend has been destroyed, so this way we ensure the backend is alive for the entire life of WKView. 1388706 11 cgarcia 2018-01-11 22:41:07 -0800 (In reply to Michael Catanzaro from comment #8) > (In reply to Michael Catanzaro from comment #7) > > Created attachment 331068 [details] > > Patch > > Alternative approach using a GRefPtr. Not sure where the best place to > declare the overloads is. What's the difference? GRefPtr will not ensure the view is destroyed before the backend, no? is it defined the order in which things happen in destructors? 1388709 12 cgarcia 2018-01-11 22:48:26 -0800 I think there's an easier approach, we can stop resetting the client in webkitFindControllerDispose. The find controller is created internally by the web view, and only destroyed when the view is destroyed. The controller is always given to the user as transfer none, so it's not expected to die before the web view in any case, that's why it doesn't take a reference to the view. So, there's no need to reset the find client, WebPageProxy already does that on close(). 1388798 13 mcatanzaro 2018-01-12 07:44:00 -0800 (In reply to Carlos Garcia Campos from comment #11) > What's the difference? GRefPtr will not ensure the view is destroyed before > the backend, no? is it defined the order in which things happen in > destructors? Yes, member variables are always constructed top-to-bottom and destroyed bottom-to-top. (In reply to Carlos Garcia Campos from comment #12) > I think there's an easier approach, we can stop resetting the client in > webkitFindControllerDispose. The find controller is created internally by > the web view, and only destroyed when the view is destroyed. The controller > is always given to the user as transfer none, so it's not expected to die > before the web view in any case, that's why it doesn't take a reference to > the view. So, there's no need to reset the find client, WebPageProxy already > does that on close(). Yes, good point. If it's safe for WebKitFindController to not keep a weak ref to the WebKitWebView -- and it is -- then it's also safe for it to not reset the client. Maybe we should do both. Using GRefPtr is more robust because it ensures getPage() will always function properly in WPE until the WKWPE::View is destroyed. Currently, getPage() is always safe to use while WebKitWebView is being destroyed in GTK, because it works as long as WebKitWebViewBase is valid, but it's not safe in WPE. Unless we ensure that WKWPE::View is destroyed last, we'll always have this disparity between the two ports, and we'll reintroduce similar problems in the future. 1389115 14 mcatanzaro 2018-01-13 09:00:14 -0800 So my suggestion is to take my GRefPtr patch, since that will ensure a consistent destruction order between GTK and WPE. And then... (In reply to Carlos Garcia Campos from comment #12) > I think there's an easier approach, we can stop resetting the client in > webkitFindControllerDispose. ...additionally, throw in this one-line change for good measure. 1391510 15 mcatanzaro 2018-01-21 16:46:57 -0800 Again, concern with changing only WebKitFindController is that having different order of destruction for WebKitWebView's priv members is likely to lead to other bugs in the future. Specifically, it seems the fact that getPage() can be used when finalizing the priv members in GTK but not WPE seems like quite a footgun. Carlos, what do you think? Please pick a solution, and I'll prepare a patch accordingly. 1391556 16 cgarcia 2018-01-21 23:23:50 -0800 (In reply to Michael Catanzaro from comment #13) > (In reply to Carlos Garcia Campos from comment #11) > > What's the difference? GRefPtr will not ensure the view is destroyed before > > the backend, no? is it defined the order in which things happen in > > destructors? > > Yes, member variables are always constructed top-to-bottom and destroyed > bottom-to-top. Still weak, if we forget about this and change the order of the members in the struct for whatever reason, this will break again. I prefer to explicitly destroy the things that need to happen in a specific order in the destructor. > (In reply to Carlos Garcia Campos from comment #12) > > I think there's an easier approach, we can stop resetting the client in > > webkitFindControllerDispose. The find controller is created internally by > > the web view, and only destroyed when the view is destroyed. The controller > > is always given to the user as transfer none, so it's not expected to die > > before the web view in any case, that's why it doesn't take a reference to > > the view. So, there's no need to reset the find client, WebPageProxy already > > does that on close(). > > Yes, good point. If it's safe for WebKitFindController to not keep a weak > ref to the WebKitWebView -- and it is -- then it's also safe for it to not > reset the client. > > Maybe we should do both. Using GRefPtr is more robust because it ensures > getPage() will always function properly in WPE until the WKWPE::View is > destroyed. Currently, getPage() is always safe to use while WebKitWebView is > being destroyed in GTK, because it works as long as WebKitWebViewBase is > valid, but it's not safe in WPE. Unless we ensure that WKWPE::View is > destroyed last, we'll always have this disparity between the two ports, and > we'll reintroduce similar problems in the future. If destroying the view is the last thing the destructor does, I don't think there will be much difference, no? 1391602 17 mcatanzaro 2018-01-22 05:07:39 -0800 (In reply to Carlos Garcia Campos from comment #16) > If destroying the view is the last thing the destructor does, I don't think > there will be much difference, no? No, because the code you write in the destructor executes *before* the priv members are destroyed. But in GTK, the equivalent of the WKWPE::View is actually WebKitWebViewBase, which is guaranteed to be valid until all priv members have been fully destroyed. So explicitly destroying things that need to happen in a certain order is not really possible. It *would* be possible to explicitly destroy things that need to be destroyed before the WKWPE::View, but in that case, I would say it's better to just reorder the members. It should be well-understood that the order of data members can be important in C++. Now, if you don't want to use GRefPtr, I think the next best thing would be to sabotage getPage() so that it no longer works once the destructor has begun executing. That's the only way I can think of to ensure the order is not important, and guarantee that we won't accidentally break WPE when we introduce calls to getPage() that are safe in GTK but illegal in WPE. But that is going to be annoying: seems much nicer to ensure getPage() works for as long as possible, right? That is, I prefer to make this safe in WPE, rather than make it unsafe in GTK. By using GRefPtr, I've ensured getPage() is always safe to call until the very last priv member is destroyed. 1391603 18 mcatanzaro 2018-01-22 05:13:22 -0800 (In reply to Michael Catanzaro from comment #17) > (In reply to Carlos Garcia Campos from comment #16) > > If destroying the view is the last thing the destructor does, I don't think > > there will be much difference, no? > > No, because the code you write in the destructor executes *before* the priv > members are destroyed. But in GTK, the equivalent of the WKWPE::View is > actually WebKitWebViewBase, which is guaranteed to be valid until all priv > members have been fully destroyed. > > So explicitly destroying things that need to happen in a certain order is > not really possible. It *would* be possible to explicitly destroy things > that need to be destroyed before the WKWPE::View, but in that case, I would > say it's better to just reorder the members. It should be well-understood > that the order of data members can be important in C++. Let me rewrite this is a less-confusing way... Any attempt to explicitly destroy the WKWPE::View will necessarily cause it to be destroyed before all the priv members that are not explicitly destroyed. That means getPage() will be unsafe during destruction of most priv members. And that is counterproductive. Unless we change it to be unsafe in GTK as well, we'll accidentally break WPE without realizing it. Suggestions: * We should either change getPage() to be safe to use during priv member destruction in WPE, or make it unsafe in GTK, so we don't accidentally break WPE without noticing by doing something that is perfectly safe in GTK. * If we want to make it safe in WPE, it follows that we must not explicitly destroy the WKWPE::View. Rather, we should just ensure it remains at the top of the list of priv members, so that it gets destroyed first. * If we instead want to make it unsafe in GTK, we can just add bool priv member and an assert to check that the priv destructor has not yet begun executing, to cause getPage() to crash when it would otherwise work perfectly fine in GTK. 1391615 19 cgarcia 2018-01-22 05:54:44 -0800 Ok, let's use GRefPtr then. 1391643 20 mcatanzaro 2018-01-22 08:41:46 -0800 (In reply to Carlos Garcia Campos from comment #19) > Ok, let's use GRefPtr then. OK... r? I'll plan to change the patch to stop resetting the client in webkitFindControllerDispose; that's just removing one line. 1391673 21 mcatanzaro 2018-01-22 09:34:42 -0800 (In reply to Michael Catanzaro from comment #20) > I'll plan to change the patch to stop resetting the client in > webkitFindControllerDispose; that's just removing one line. Er, actually it's the only line in dispose, so I'll remove all of dispose.... 1391677 22 mcatanzaro 2018-01-22 09:45:06 -0800 (In reply to Michael Catanzaro from comment #20) > I'll plan to change the patch to stop resetting the client in > webkitFindControllerDispose; that's just removing one line. Actually, I think it's safer to keep that line, because: * This commit makes it perfectly safe to use getPage there(), so it's at worst harmless * Unsetting the find client is safer as it avoids potential calls to the WebKitFindController after its destruction, during the destruction of the WebKitWebView It's a very minor point, though, so we could go either way, but keeping it seems slightly better. I'll wait until tomorrow before committing, in case you object. 1391975 23 cgarcia 2018-01-22 22:18:13 -0800 (In reply to Michael Catanzaro from comment #22) > (In reply to Michael Catanzaro from comment #20) > > I'll plan to change the patch to stop resetting the client in > > webkitFindControllerDispose; that's just removing one line. > > Actually, I think it's safer to keep that line, because: > > * This commit makes it perfectly safe to use getPage there(), so it's at > worst harmless > * Unsetting the find client is safer as it avoids potential calls to the > WebKitFindController after its destruction, during the destruction of the > WebKitWebView > > It's a very minor point, though, so we could go either way, but keeping it > seems slightly better. I'll wait until tomorrow before committing, in case > you object. It gives the wrong impression that the find controller can be alive after the web view, like we thought before investigating this issue. 1392065 24 mcatanzaro 2018-01-23 08:27:39 -0800 OK, I'll remove it. 1392066 25 mcatanzaro 2018-01-23 08:34:38 -0800 (In reply to Michael Catanzaro from comment #6) > No wait, it's not a great idea. WebKitWebView holds a ref on the > WebKitFindController, so there's no reason for WebKitFindController to need > a weak pointer. WebKitWebView should be valid for its entire lifetime. It's > simpler to just fix the order of destruction. ^ That comment is totally wrong. The guarantee is that WebKitFindController will be valid for the lifetime of the WebKitWebView, not that WebKitWebView will be valid for the lifetime of the WebKitFindController. It's easy to see how that might not be the case, if an application refs the WebKitFindController and then unrefs the WebKitWebView. So your suggestion in comment #4 is valid. But it's an orthogonal problem to this bug. Using the weak pointer would not help to fix this bug. 1392067 26 mcatanzaro 2018-01-23 08:39:10 -0800 (In reply to Carlos Garcia Campos from comment #23) > It gives the wrong impression that the find controller can be alive after > the web view, like we thought before investigating this issue. Your comment here is almost correct: unsetting the FindClient gives the wrong impression that the *WebKitWebView* can be alive after the *WebKitFindController* (which is really not possible). So I will do as you recommend, and remove the code that unsets the FindClient. Then considering whether to use a weak pointer would be another bug. We probably should, though it would only matter if an application uses WebKitFindController in a strange and unexpected way. 1392069 27 332030 mcatanzaro 2018-01-23 08:40:09 -0800 Created attachment 332030 Patch 1392078 28 mcatanzaro 2018-01-23 09:19:48 -0800 Committed r227418: <https://trac.webkit.org/changeset/227418> 330935 2018-01-10 11:27:04 -0800 2018-01-23 08:40:03 -0800 Patch bug-181472-20180110132702.patch text/plain 1413 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjI2NjQwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGIxZDY0M2Q3ZTUwYTdiYTky YjNiMmRmODk2MmViZGU0M2Q2MmIzZTkuLjZkZDQwMTQ1ZmI2OWY1ZjhlY2ExNGNkNjQyYzU0OTA3 MmNiODQyYjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTgtMDEtMTAgIE1pY2hhZWwg Q2F0YW56YXJvICA8bWNhdGFuemFyb0BpZ2FsaWEuY29tPgorCisgICAgICAgIFtXUEVdIFRlc3RX ZWJLaXRGaW5kQ29udHJvbGxlciBhc3NlcnRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xODE0NzIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBFbnN1cmUgdGhlIFdlYktpdEZpbmRDb250cm9sbGVyIGlzIGRl c3Ryb3llZCBiZWZvcmUgdGhlIFdLV1BFOjpWaWV3LgorCisgICAgICAgICogVUlQcm9jZXNzL0FQ SS9nbGliL1dlYktpdFdlYlZpZXcuY3BwOgorICAgICAgICAoX1dlYktpdFdlYlZpZXdQcml2YXRl Ojp+X1dlYktpdFdlYlZpZXdQcml2YXRlKToKKwogMjAxOC0wMS0wOSAgQ2FybG9zIEdhcmNpYSBD YW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZC4gVXBkYXRl IE9wdGlvbnNHVEsuY21ha2UgYW5kIE5FV1MgZm9yIDIuMTkuNSByZWxlYXNlLgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2ViVmlldy5jcHAgYi9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJWaWV3LmNwcAppbmRleCBi MTNjMzU0NDNjMGE1NTI5MWEwYzA3NzA4ZDVkMmQ3Y2Q5MWVjZWIwLi5mMmViNmVjYTNkNDU5NjBl NTVlYTBlYTc5MDNlNGQ5NmEyYmYxMDY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJWaWV3LmNwcApAQCAtMTk5LDYgKzE5OSw3IEBAIHN0cnVj dCBfV2ViS2l0V2ViVmlld1ByaXZhdGUgewogICAgICAgICBpZiAobW9kYWxMb29wICYmIGdfbWFp bl9sb29wX2lzX3J1bm5pbmcobW9kYWxMb29wLmdldCgpKSkKICAgICAgICAgICAgIGdfbWFpbl9s b29wX3F1aXQobW9kYWxMb29wLmdldCgpKTsKICNpZiBQTEFURk9STShXUEUpCisgICAgICAgIGZp bmRDb250cm9sbGVyID0gbnVsbHB0cjsKICAgICAgICAgdmlldyA9IG51bGxwdHI7CiAgICAgICAg IHdlYmtpdFdlYlZpZXdCYWNrZW5kVW5yZWYoYmFja2VuZCk7CiAjZW5kaWYK 331068 2018-01-11 10:23:25 -0800 2018-01-23 08:40:05 -0800 Patch bug-181472-20180111122324.patch text/plain 5827 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjI2NzI4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDBmZmUzZjE1NzIyZGZkZGMx ZDY0MTM4ODU1YmE5MTUzZGNkMWI2ZDEuLjU5Y2VlZmVlNzU1ZTYzZTNiYTcyYzNhNTdiZjdhOTQz ZTcwNzM5ZmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMTgtMDEtMTEgIE1pY2hhZWwg Q2F0YW56YXJvICA8bWNhdGFuemFyb0BpZ2FsaWEuY29tPgorCisgICAgICAgIFtXUEVdIFRlc3RX ZWJLaXRGaW5kQ29udHJvbGxlciBhc3NlcnRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xODE0NzIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBVc2UgYSBHUmVmUHRyIHRvIGhvbGQgb3duZXJzaGlwIG9mIHRo ZSBXZWJLaXRXZWJWaWV3QmFja2VuZC4gVGhpcyB3YXksIHdlIGRvbid0IG5lZWQgdG8KKyAgICAg ICAgY2hhbmdlIHRoZSBvcmRlciBpbiB3aGljaCBXZWJLaXRXZWJWaWV3IGRlc3Ryb3lzIGl0cyBw cml2IHN0cnVjdCBtZW1iZXJzIGZyb20gd2hhdCBpcyB1c2VkCisgICAgICAgIGluIFdlYktpdEdU SyssIHdoaWNoIGNhbiBsZWFkIHRvIG9kZCBidWdzLgorCisgICAgICAgICogVUlQcm9jZXNzL0FQ SS9nbGliL1dlYktpdFdlYlZpZXcuY3BwOgorICAgICAgICAoX1dlYktpdFdlYlZpZXdQcml2YXRl Ojp+X1dlYktpdFdlYlZpZXdQcml2YXRlKToKKyAgICAgICAgKHdlYmtpdFdlYlZpZXdTZXRQcm9w ZXJ0eSk6CisgICAgICAgICh3ZWJraXRXZWJWaWV3R2V0UHJvcGVydHkpOgorICAgICAgICAod2Vi a2l0V2ViVmlld0NyZWF0ZVBhZ2UpOgorICAgICAgICAod2Via2l0X3dlYl92aWV3X2dldF9iYWNr ZW5kKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL3dwZS9XZWJLaXRXZWJWaWV3QmFja2VuZC5j cHA6CisgICAgICAgICh3ZWJraXRXZWJWaWV3QmFja2VuZENyZWF0ZURlZmF1bHQpOgorICAgICAg ICAoV1RGOjpyZWZHUHRyKToKKyAgICAgICAgKFdURjo6ZGVyZWZHUHRyKToKKyAgICAgICAgKiBV SVByb2Nlc3MvQVBJL3dwZS9XZWJLaXRXZWJWaWV3QmFja2VuZFByaXZhdGUuaDoKKwogMjAxOC0w MS0wOSAgSm9obiBXaWxhbmRlciAgPHdpbGFuZGVyQGFwcGxlLmNvbT4KIAogICAgICAgICBTdG9y YWdlIEFjY2VzcyBBUEk6IFR1cm4gZmVhdHVyZSBvbiBieSBkZWZhdWx0IGluIFdlYlByZWZlcmVu Y2VzLnlhbWwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGliL1dl YktpdFdlYlZpZXcuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0 V2ViVmlldy5jcHAKaW5kZXggYjEzYzM1NDQzYzBhNTUyOTFhMGMwNzcwOGQ1ZDJkN2NkOTFlY2Vi MC4uNTFjY2Q3NzU1ZjIwZWViNGNkY2Q1NDZhY2I3ODI2Yzk4ODExYzkyOSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2ViVmlldy5jcHAKKysrIGIv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2ViVmlldy5jcHAKQEAgLTE5 OCwxNCArMTk4LDEwIEBAIHN0cnVjdCBfV2ViS2l0V2ViVmlld1ByaXZhdGUgewogICAgICAgICAv LyBGb3IgbW9kYWwgZGlhbG9ncywgbWFrZSBzdXJlIHRoZSBtYWluIGxvb3AgaXMgc3RvcHBlZCB3 aGVuIGZpbmFsaXppbmcgdGhlIHdlYlZpZXcuCiAgICAgICAgIGlmIChtb2RhbExvb3AgJiYgZ19t YWluX2xvb3BfaXNfcnVubmluZyhtb2RhbExvb3AuZ2V0KCkpKQogICAgICAgICAgICAgZ19tYWlu X2xvb3BfcXVpdChtb2RhbExvb3AuZ2V0KCkpOwotI2lmIFBMQVRGT1JNKFdQRSkKLSAgICAgICAg dmlldyA9IG51bGxwdHI7Ci0gICAgICAgIHdlYmtpdFdlYlZpZXdCYWNrZW5kVW5yZWYoYmFja2Vu ZCk7Ci0jZW5kaWYKICAgICB9CiAKICNpZiBQTEFURk9STShXUEUpCi0gICAgV2ViS2l0V2ViVmll d0JhY2tlbmQqIGJhY2tlbmQ7CisgICAgR1JlZlB0cjxXZWJLaXRXZWJWaWV3QmFja2VuZD4gYmFj a2VuZDsKICAgICBzdGQ6OnVuaXF1ZV9wdHI8V0tXUEU6OlZpZXc+IHZpZXc7CiAjZW5kaWYKIApA QCAtNjkxLDcgKzY4Nyw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdFdlYlZpZXdTZXRQcm9wZXJ0eShH T2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BJZCwgY29uc3QgR1ZhbHVlCiAjaWYgUExBVEZPUk0o V1BFKQogICAgIGNhc2UgUFJPUF9CQUNLRU5EOiB7CiAgICAgICAgIGdwb2ludGVyIGJhY2tlbmQg PSBnX3ZhbHVlX2dldF9ib3hlZCh2YWx1ZSk7Ci0gICAgICAgIHdlYlZpZXctPnByaXYtPmJhY2tl bmQgPSBiYWNrZW5kID8gc3RhdGljX2Nhc3Q8V2ViS2l0V2ViVmlld0JhY2tlbmQqPihiYWNrZW5k KSA6IG51bGxwdHI7CisgICAgICAgIHdlYlZpZXctPnByaXYtPmJhY2tlbmQgPSBiYWNrZW5kID8g YWRvcHRHUmVmKHN0YXRpY19jYXN0PFdlYktpdFdlYlZpZXdCYWNrZW5kKj4oYmFja2VuZCkpIDog bnVsbHB0cjsKICAgICAgICAgYnJlYWs7CiAgICAgfQogI2VuZGlmCkBAIC03MzksNyArNzM1LDcg QEAgc3RhdGljIHZvaWQgd2Via2l0V2ViVmlld0dldFByb3BlcnR5KEdPYmplY3QqIG9iamVjdCwg Z3VpbnQgcHJvcElkLCBHVmFsdWUqIHZhbHUKICAgICBzd2l0Y2ggKHByb3BJZCkgewogI2lmIFBM QVRGT1JNKFdQRSkKICAgICBjYXNlIFBST1BfQkFDS0VORDoKLSAgICAgICAgZ192YWx1ZV9zZXRf c3RhdGljX2JveGVkKHZhbHVlLCB3ZWJWaWV3LT5wcml2LT5iYWNrZW5kKTsKKyAgICAgICAgZ192 YWx1ZV9zZXRfc3RhdGljX2JveGVkKHZhbHVlLCB3ZWJWaWV3LT5wcml2LT5iYWNrZW5kLmdldCgp KTsKICAgICAgICAgYnJlYWs7CiAjZW5kaWYKICAgICBjYXNlIFBST1BfV0VCX0NPTlRFWFQ6CkBA IC0xOTgzLDcgKzE5NzksNyBAQCB2b2lkIHdlYmtpdFdlYlZpZXdDcmVhdGVQYWdlKFdlYktpdFdl YlZpZXcqIHdlYlZpZXcsIFJlZjxBUEk6OlBhZ2VDb25maWd1cmF0aW9uPgogI2lmIFBMQVRGT1JN KEdUSykKICAgICB3ZWJraXRXZWJWaWV3QmFzZUNyZWF0ZVdlYlBhZ2UoV0VCS0lUX1dFQl9WSUVX X0JBU0Uod2ViVmlldyksIFdURk1vdmUoY29uZmlndXJhdGlvbikpOwogI2VsaWYgUExBVEZPUk0o V1BFKQotICAgIHdlYlZpZXctPnByaXYtPnZpZXcucmVzZXQoV0tXUEU6OlZpZXc6OmNyZWF0ZSh3 ZWJraXRfd2ViX3ZpZXdfYmFja2VuZF9nZXRfd3BlX2JhY2tlbmQod2ViVmlldy0+cHJpdi0+YmFj a2VuZCksIGNvbmZpZ3VyYXRpb24uZ2V0KCkpKTsKKyAgICB3ZWJWaWV3LT5wcml2LT52aWV3LnJl c2V0KFdLV1BFOjpWaWV3OjpjcmVhdGUod2Via2l0X3dlYl92aWV3X2JhY2tlbmRfZ2V0X3dwZV9i YWNrZW5kKHdlYlZpZXctPnByaXYtPmJhY2tlbmQuZ2V0KCkpLCBjb25maWd1cmF0aW9uLmdldCgp KSk7CiAjZW5kaWYKIH0KIApAQCAtMjQzMCw3ICsyNDI2LDcgQEAgV2ViS2l0V2ViVmlld0JhY2tl bmQqIHdlYmtpdF93ZWJfdmlld19nZXRfYmFja2VuZChXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3KQog ewogICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19XRUJfVklFVyh3ZWJWaWV3KSwg bnVsbHB0cik7CiAKLSAgICByZXR1cm4gd2ViVmlldy0+cHJpdi0+YmFja2VuZDsKKyAgICByZXR1 cm4gd2ViVmlldy0+cHJpdi0+YmFja2VuZC5nZXQoKTsKIH0KICNlbmRpZgogCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvd3BlL1dlYktpdFdlYlZpZXdCYWNrZW5kLmNw cCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvV2ViS2l0V2ViVmlld0JhY2tlbmQu Y3BwCmluZGV4IGQwYmY2MzQ5ZDNmNmNjYTcyOWRhYmIzYWRmOTgzMTUwY2I0YzJhMzAuLmQ0Y2Fk ZWU2MjcxM2I3NGYzZWQ1MDM0ZjE1OTdiNWJkMzJlMGY0NzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvV2ViS2l0V2ViVmlld0JhY2tlbmQuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvV2ViS2l0V2ViVmlld0JhY2tlbmQuY3BwCkBA IC04MiwxMSArODIsMTEgQEAgdm9pZCB3ZWJraXRXZWJWaWV3QmFja2VuZFVucmVmKFdlYktpdFdl YlZpZXdCYWNrZW5kKiB2aWV3QmFja2VuZCkKICAgICB9CiB9CiAKLVdlYktpdFdlYlZpZXdCYWNr ZW5kKiB3ZWJraXRXZWJWaWV3QmFja2VuZENyZWF0ZURlZmF1bHQoKQorR1JlZlB0cjxXZWJLaXRX ZWJWaWV3QmFja2VuZD4gd2Via2l0V2ViVmlld0JhY2tlbmRDcmVhdGVEZWZhdWx0KCkKIHsKICAg ICBhdXRvKiB2aWV3QmFja2VuZCA9IHN0YXRpY19jYXN0PFdlYktpdFdlYlZpZXdCYWNrZW5kKj4o ZmFzdE1hbGxvYyhzaXplb2YoV2ViS2l0V2ViVmlld0JhY2tlbmQpKSk7CiAgICAgbmV3ICh2aWV3 QmFja2VuZCkgV2ViS2l0V2ViVmlld0JhY2tlbmQoKTsKLSAgICByZXR1cm4gdmlld0JhY2tlbmQ7 CisgICAgcmV0dXJuIGFkb3B0R1JlZih2aWV3QmFja2VuZCk7CiB9CiAKIC8qKgpAQCAtMTI5LDMg KzEyOSwyMCBAQCBzdHJ1Y3Qgd3BlX3ZpZXdfYmFja2VuZCogd2Via2l0X3dlYl92aWV3X2JhY2tl bmRfZ2V0X3dwZV9iYWNrZW5kKFdlYktpdFdlYlZpZXdCYQogICAgIGdfcmV0dXJuX3ZhbF9pZl9m YWlsKHZpZXdCYWNrZW5kLCBudWxscHRyKTsKICAgICByZXR1cm4gdmlld0JhY2tlbmQtPmJhY2tl bmQ7CiB9CisKK25hbWVzcGFjZSBXVEYgeworCit0ZW1wbGF0ZSA8PiBXZWJLaXRXZWJWaWV3QmFj a2VuZCogcmVmR1B0cihXZWJLaXRXZWJWaWV3QmFja2VuZCogcHRyKQoreworICAgIGlmIChwdHIp CisgICAgICAgIHdlYmtpdFdlYlZpZXdCYWNrZW5kUmVmKHB0cik7CisgICAgcmV0dXJuIHB0cjsK K30KKwordGVtcGxhdGUgPD4gdm9pZCBkZXJlZkdQdHIoV2ViS2l0V2ViVmlld0JhY2tlbmQqIHB0 cikKK3sKKyAgICBpZiAocHRyKQorICAgICAgICB3ZWJraXRXZWJWaWV3QmFja2VuZFVucmVmKHB0 cik7Cit9CisKK30KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUv V2ViS2l0V2ViVmlld0JhY2tlbmRQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvd3BlL1dlYktpdFdlYlZpZXdCYWNrZW5kUHJpdmF0ZS5oCmluZGV4IGE4ZTQ1MWIzMTcwYzli ZmM4NzYxNWMwZmNhNjM5MWM1NWZjNTFiOWMuLmQ4ZDY1ZThkNjFkZWUxODM2YzU0N2RjN2I4NGYx NzIxNzA3MGI3ZDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUv V2ViS2l0V2ViVmlld0JhY2tlbmRQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvQVBJL3dwZS9XZWJLaXRXZWJWaWV3QmFja2VuZFByaXZhdGUuaApAQCAtMjEsNSArMjEsMTQg QEAKIAogI2luY2x1ZGUgIldlYktpdFdlYlZpZXdCYWNrZW5kLmgiCiAKKyNpbmNsdWRlIDx3dGYv Z2xpYi9HUmVmUHRyLmg+CisKK25hbWVzcGFjZSBXVEYgeworCit0ZW1wbGF0ZSA8PiBXZWJLaXRX ZWJWaWV3QmFja2VuZCogcmVmR1B0cihXZWJLaXRXZWJWaWV3QmFja2VuZCogcHRyKTsKK3RlbXBs YXRlIDw+IHZvaWQgZGVyZWZHUHRyKFdlYktpdFdlYlZpZXdCYWNrZW5kKiBwdHIpOworCit9CisK IHZvaWQgd2Via2l0V2ViVmlld0JhY2tlbmRVbnJlZihXZWJLaXRXZWJWaWV3QmFja2VuZCopOwot V2ViS2l0V2ViVmlld0JhY2tlbmQqIHdlYmtpdFdlYlZpZXdCYWNrZW5kQ3JlYXRlRGVmYXVsdCgp OworR1JlZlB0cjxXZWJLaXRXZWJWaWV3QmFja2VuZD4gd2Via2l0V2ViVmlld0JhY2tlbmRDcmVh dGVEZWZhdWx0KCk7Cg== 332030 2018-01-23 08:40:09 -0800 2018-01-23 08:40:09 -0800 Patch bug-181472-20180123104006.patch text/plain 7557 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjI3NDE0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDU5N2FhMzI5OTExYTdlNzFm MmFkYmNlMTkyODQ0MmJhZGZjOGE3YzguLjk2YTUzMDZiZDE4ZDRjNDk4NTQzNDg0ZmU1Zjk3NWIy MjZmNDMxOWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAKKzIwMTgtMDEtMjMgIE1pY2hhZWwg Q2F0YW56YXJvICA8bWNhdGFuemFyb0BpZ2FsaWEuY29tPgorCisgICAgICAgIFtXUEVdIFRlc3RX ZWJLaXRGaW5kQ29udHJvbGxlciBhc3NlcnRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xODE0NzIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBMZXQncyBmaXggdGhpcyBpbiB0d28gaW5kZXBlbmRlbnQgd2F5 cy4KKworICAgICAgICBGaXJzdCwgdXNlIGEgR1JlZlB0ciB0byBob2xkIG93bmVyc2hpcCBvZiB0 aGUgV2ViS2l0V2ViVmlld0JhY2tlbmQuIFRoaXMgd2F5LCB3ZSBkb24ndCBuZWVkCisgICAgICAg IHRvIGNoYW5nZSB0aGUgb3JkZXIgaW4gd2hpY2ggV2ViS2l0V2ViVmlldyBkZXN0cm95cyBpdHMg cHJpdiBzdHJ1Y3QgbWVtYmVycyBmcm9tIHdoYXQgaXMKKyAgICAgICAgdXNlZCBpbiBXZWJLaXRH VEsrLCB3aGljaCBjYW4gbGVhZCB0byBvZGQgYnVncy4KKworICAgICAgICBBZGRpdGlvbmFsbHks IGp1c3QgZm9yIGdvb2QgbWVhc3VyZSwgc3RvcCByZXNldHRpbmcgdGhlIGZpbmQgY2xpZW50IHdo ZW4gZGlzcG9zaW5nCisgICAgICAgIFdlYktpdEZpbmRDb250cm9sbGVyLiBUaGlzIGlzIHVubmVj ZXNzYXJ5IGJlY2F1c2UgaXQgd2lsbCBuZXZlciBiZSBkZXN0cm95ZWQgYmVmb3JlIHRoZQorICAg ICAgICBXZWJLaXRXZWJWaWV3LgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9nbGliL1dlYktp dEZpbmRDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKHdlYmtpdF9maW5kX2NvbnRyb2xsZXJfY2xh c3NfaW5pdCk6CisgICAgICAgICh3ZWJraXRGaW5kQ29udHJvbGxlckRpc3Bvc2UpOiBEZWxldGVk LgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJWaWV3LmNwcDoKKyAgICAg ICAgKF9XZWJLaXRXZWJWaWV3UHJpdmF0ZTo6fl9XZWJLaXRXZWJWaWV3UHJpdmF0ZSk6CisgICAg ICAgICh3ZWJraXRXZWJWaWV3U2V0UHJvcGVydHkpOgorICAgICAgICAod2Via2l0V2ViVmlld0dl dFByb3BlcnR5KToKKyAgICAgICAgKHdlYmtpdFdlYlZpZXdDcmVhdGVQYWdlKToKKyAgICAgICAg KHdlYmtpdF93ZWJfdmlld19nZXRfYmFja2VuZCk6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS93 cGUvV2ViS2l0V2ViVmlld0JhY2tlbmQuY3BwOgorICAgICAgICAod2Via2l0V2ViVmlld0JhY2tl bmRDcmVhdGVEZWZhdWx0KToKKyAgICAgICAgKFdURjo6cmVmR1B0cik6CisgICAgICAgIChXVEY6 OmRlcmVmR1B0cik6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS93cGUvV2ViS2l0V2ViVmlld0Jh Y2tlbmRQcml2YXRlLmg6CisKIDIwMTgtMDEtMjIgIEpvbiBMZWUgIDxqb25sZWVAYXBwbGUuY29t PgogCiAgICAgICAgIFVwZGF0ZSB0aXRsZSBsYWJlbCBzaXplCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRGaW5kQ29udHJvbGxlci5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRGaW5kQ29udHJvbGxlci5jcHAKaW5k ZXggMjgzMTc3ZGEzYmE5MThhMTRkNmNlYmExNzFhNzdlZmExYjk3MDFjZS4uNGY5ODBkNGVlMjU4 YWNhYzQ1NTgzMjNjYTdiZDcxY2NkZjNiZWViMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9V SVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0RmluZENvbnRyb2xsZXIuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdEZpbmRDb250cm9sbGVyLmNwcApAQCAtMTMy LDE0ICsxMzIsNiBAQCBwcml2YXRlOgogICAgIFdlYktpdEZpbmRDb250cm9sbGVyKiBtX2ZpbmRD b250cm9sbGVyOwogfTsKIAotc3RhdGljIHZvaWQgd2Via2l0RmluZENvbnRyb2xsZXJEaXNwb3Nl KEdPYmplY3QqIG9iamVjdCkKLXsKLSAgICBXZWJLaXRGaW5kQ29udHJvbGxlciogZmluZENvbnRy b2xsZXIgPSBXRUJLSVRfRklORF9DT05UUk9MTEVSKG9iamVjdCk7Ci0gICAgZ2V0UGFnZShmaW5k Q29udHJvbGxlcikuc2V0RmluZENsaWVudChudWxscHRyKTsKLQotICAgIEdfT0JKRUNUX0NMQVNT KHdlYmtpdF9maW5kX2NvbnRyb2xsZXJfcGFyZW50X2NsYXNzKS0+ZGlzcG9zZShvYmplY3QpOwot fQotCiBzdGF0aWMgdm9pZCB3ZWJraXRGaW5kQ29udHJvbGxlckNvbnN0cnVjdGVkKEdPYmplY3Qq IG9iamVjdCkKIHsKICAgICBHX09CSkVDVF9DTEFTUyh3ZWJraXRfZmluZF9jb250cm9sbGVyX3Bh cmVudF9jbGFzcyktPmNvbnN0cnVjdGVkKG9iamVjdCk7CkBAIC0xODYsNyArMTc4LDYgQEAgc3Rh dGljIHZvaWQgd2Via2l0RmluZENvbnRyb2xsZXJTZXRQcm9wZXJ0eShHT2JqZWN0KiBvYmplY3Qs IGd1aW50IHByb3BJZCwgY29uc3QKIHN0YXRpYyB2b2lkIHdlYmtpdF9maW5kX2NvbnRyb2xsZXJf Y2xhc3NfaW5pdChXZWJLaXRGaW5kQ29udHJvbGxlckNsYXNzKiBmaW5kQ2xhc3MpCiB7CiAgICAg R09iamVjdENsYXNzKiBnT2JqZWN0Q2xhc3MgPSBHX09CSkVDVF9DTEFTUyhmaW5kQ2xhc3MpOwot ICAgIGdPYmplY3RDbGFzcy0+ZGlzcG9zZSA9IHdlYmtpdEZpbmRDb250cm9sbGVyRGlzcG9zZTsK ICAgICBnT2JqZWN0Q2xhc3MtPmNvbnN0cnVjdGVkID0gd2Via2l0RmluZENvbnRyb2xsZXJDb25z dHJ1Y3RlZDsKICAgICBnT2JqZWN0Q2xhc3MtPmdldF9wcm9wZXJ0eSA9IHdlYmtpdEZpbmRDb250 cm9sbGVyR2V0UHJvcGVydHk7CiAgICAgZ09iamVjdENsYXNzLT5zZXRfcHJvcGVydHkgPSB3ZWJr aXRGaW5kQ29udHJvbGxlclNldFByb3BlcnR5OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9V SVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0V2ViVmlldy5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJWaWV3LmNwcAppbmRleCBiMTNjMzU0NDNjMGE1NTI5MWEw YzA3NzA4ZDVkMmQ3Y2Q5MWVjZWIwLi41MWNjZDc3NTVmMjBlZWI0Y2RjZDU0NmFjYjc4MjZjOTg4 MTFjOTI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJL aXRXZWJWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJL aXRXZWJWaWV3LmNwcApAQCAtMTk4LDE0ICsxOTgsMTAgQEAgc3RydWN0IF9XZWJLaXRXZWJWaWV3 UHJpdmF0ZSB7CiAgICAgICAgIC8vIEZvciBtb2RhbCBkaWFsb2dzLCBtYWtlIHN1cmUgdGhlIG1h aW4gbG9vcCBpcyBzdG9wcGVkIHdoZW4gZmluYWxpemluZyB0aGUgd2ViVmlldy4KICAgICAgICAg aWYgKG1vZGFsTG9vcCAmJiBnX21haW5fbG9vcF9pc19ydW5uaW5nKG1vZGFsTG9vcC5nZXQoKSkp CiAgICAgICAgICAgICBnX21haW5fbG9vcF9xdWl0KG1vZGFsTG9vcC5nZXQoKSk7Ci0jaWYgUExB VEZPUk0oV1BFKQotICAgICAgICB2aWV3ID0gbnVsbHB0cjsKLSAgICAgICAgd2Via2l0V2ViVmll d0JhY2tlbmRVbnJlZihiYWNrZW5kKTsKLSNlbmRpZgogICAgIH0KIAogI2lmIFBMQVRGT1JNKFdQ RSkKLSAgICBXZWJLaXRXZWJWaWV3QmFja2VuZCogYmFja2VuZDsKKyAgICBHUmVmUHRyPFdlYktp dFdlYlZpZXdCYWNrZW5kPiBiYWNrZW5kOwogICAgIHN0ZDo6dW5pcXVlX3B0cjxXS1dQRTo6Vmll dz4gdmlldzsKICNlbmRpZgogCkBAIC02OTEsNyArNjg3LDcgQEAgc3RhdGljIHZvaWQgd2Via2l0 V2ViVmlld1NldFByb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcElkLCBjb25zdCBH VmFsdWUKICNpZiBQTEFURk9STShXUEUpCiAgICAgY2FzZSBQUk9QX0JBQ0tFTkQ6IHsKICAgICAg ICAgZ3BvaW50ZXIgYmFja2VuZCA9IGdfdmFsdWVfZ2V0X2JveGVkKHZhbHVlKTsKLSAgICAgICAg d2ViVmlldy0+cHJpdi0+YmFja2VuZCA9IGJhY2tlbmQgPyBzdGF0aWNfY2FzdDxXZWJLaXRXZWJW aWV3QmFja2VuZCo+KGJhY2tlbmQpIDogbnVsbHB0cjsKKyAgICAgICAgd2ViVmlldy0+cHJpdi0+ YmFja2VuZCA9IGJhY2tlbmQgPyBhZG9wdEdSZWYoc3RhdGljX2Nhc3Q8V2ViS2l0V2ViVmlld0Jh Y2tlbmQqPihiYWNrZW5kKSkgOiBudWxscHRyOwogICAgICAgICBicmVhazsKICAgICB9CiAjZW5k aWYKQEAgLTczOSw3ICs3MzUsNyBAQCBzdGF0aWMgdm9pZCB3ZWJraXRXZWJWaWV3R2V0UHJvcGVy dHkoR09iamVjdCogb2JqZWN0LCBndWludCBwcm9wSWQsIEdWYWx1ZSogdmFsdQogICAgIHN3aXRj aCAocHJvcElkKSB7CiAjaWYgUExBVEZPUk0oV1BFKQogICAgIGNhc2UgUFJPUF9CQUNLRU5EOgot ICAgICAgICBnX3ZhbHVlX3NldF9zdGF0aWNfYm94ZWQodmFsdWUsIHdlYlZpZXctPnByaXYtPmJh Y2tlbmQpOworICAgICAgICBnX3ZhbHVlX3NldF9zdGF0aWNfYm94ZWQodmFsdWUsIHdlYlZpZXct PnByaXYtPmJhY2tlbmQuZ2V0KCkpOwogICAgICAgICBicmVhazsKICNlbmRpZgogICAgIGNhc2Ug UFJPUF9XRUJfQ09OVEVYVDoKQEAgLTE5ODMsNyArMTk3OSw3IEBAIHZvaWQgd2Via2l0V2ViVmll d0NyZWF0ZVBhZ2UoV2ViS2l0V2ViVmlldyogd2ViVmlldywgUmVmPEFQSTo6UGFnZUNvbmZpZ3Vy YXRpb24+CiAjaWYgUExBVEZPUk0oR1RLKQogICAgIHdlYmtpdFdlYlZpZXdCYXNlQ3JlYXRlV2Vi UGFnZShXRUJLSVRfV0VCX1ZJRVdfQkFTRSh3ZWJWaWV3KSwgV1RGTW92ZShjb25maWd1cmF0aW9u KSk7CiAjZWxpZiBQTEFURk9STShXUEUpCi0gICAgd2ViVmlldy0+cHJpdi0+dmlldy5yZXNldChX S1dQRTo6Vmlldzo6Y3JlYXRlKHdlYmtpdF93ZWJfdmlld19iYWNrZW5kX2dldF93cGVfYmFja2Vu ZCh3ZWJWaWV3LT5wcml2LT5iYWNrZW5kKSwgY29uZmlndXJhdGlvbi5nZXQoKSkpOworICAgIHdl YlZpZXctPnByaXYtPnZpZXcucmVzZXQoV0tXUEU6OlZpZXc6OmNyZWF0ZSh3ZWJraXRfd2ViX3Zp ZXdfYmFja2VuZF9nZXRfd3BlX2JhY2tlbmQod2ViVmlldy0+cHJpdi0+YmFja2VuZC5nZXQoKSks IGNvbmZpZ3VyYXRpb24uZ2V0KCkpKTsKICNlbmRpZgogfQogCkBAIC0yNDMwLDcgKzI0MjYsNyBA QCBXZWJLaXRXZWJWaWV3QmFja2VuZCogd2Via2l0X3dlYl92aWV3X2dldF9iYWNrZW5kKFdlYktp dFdlYlZpZXcqIHdlYlZpZXcpCiB7CiAgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lT X1dFQl9WSUVXKHdlYlZpZXcpLCBudWxscHRyKTsKIAotICAgIHJldHVybiB3ZWJWaWV3LT5wcml2 LT5iYWNrZW5kOworICAgIHJldHVybiB3ZWJWaWV3LT5wcml2LT5iYWNrZW5kLmdldCgpOwogfQog I2VuZGlmCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvV2Vi S2l0V2ViVmlld0JhY2tlbmQuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9X ZWJLaXRXZWJWaWV3QmFja2VuZC5jcHAKaW5kZXggZDBiZjYzNDlkM2Y2Y2NhNzI5ZGFiYjNhZGY5 ODMxNTBjYjRjMmEzMC4uZDRjYWRlZTYyNzEzYjc0ZjNlZDUwMzRmMTU5N2I1YmQzMmUwZjQ3OCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9XZWJLaXRXZWJWaWV3 QmFja2VuZC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9XZWJLaXRX ZWJWaWV3QmFja2VuZC5jcHAKQEAgLTgyLDExICs4MiwxMSBAQCB2b2lkIHdlYmtpdFdlYlZpZXdC YWNrZW5kVW5yZWYoV2ViS2l0V2ViVmlld0JhY2tlbmQqIHZpZXdCYWNrZW5kKQogICAgIH0KIH0K IAotV2ViS2l0V2ViVmlld0JhY2tlbmQqIHdlYmtpdFdlYlZpZXdCYWNrZW5kQ3JlYXRlRGVmYXVs dCgpCitHUmVmUHRyPFdlYktpdFdlYlZpZXdCYWNrZW5kPiB3ZWJraXRXZWJWaWV3QmFja2VuZENy ZWF0ZURlZmF1bHQoKQogewogICAgIGF1dG8qIHZpZXdCYWNrZW5kID0gc3RhdGljX2Nhc3Q8V2Vi S2l0V2ViVmlld0JhY2tlbmQqPihmYXN0TWFsbG9jKHNpemVvZihXZWJLaXRXZWJWaWV3QmFja2Vu ZCkpKTsKICAgICBuZXcgKHZpZXdCYWNrZW5kKSBXZWJLaXRXZWJWaWV3QmFja2VuZCgpOwotICAg IHJldHVybiB2aWV3QmFja2VuZDsKKyAgICByZXR1cm4gYWRvcHRHUmVmKHZpZXdCYWNrZW5kKTsK IH0KIAogLyoqCkBAIC0xMjksMyArMTI5LDIwIEBAIHN0cnVjdCB3cGVfdmlld19iYWNrZW5kKiB3 ZWJraXRfd2ViX3ZpZXdfYmFja2VuZF9nZXRfd3BlX2JhY2tlbmQoV2ViS2l0V2ViVmlld0JhCiAg ICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodmlld0JhY2tlbmQsIG51bGxwdHIpOwogICAgIHJldHVy biB2aWV3QmFja2VuZC0+YmFja2VuZDsKIH0KKworbmFtZXNwYWNlIFdURiB7CisKK3RlbXBsYXRl IDw+IFdlYktpdFdlYlZpZXdCYWNrZW5kKiByZWZHUHRyKFdlYktpdFdlYlZpZXdCYWNrZW5kKiBw dHIpCit7CisgICAgaWYgKHB0cikKKyAgICAgICAgd2Via2l0V2ViVmlld0JhY2tlbmRSZWYocHRy KTsKKyAgICByZXR1cm4gcHRyOworfQorCit0ZW1wbGF0ZSA8PiB2b2lkIGRlcmVmR1B0cihXZWJL aXRXZWJWaWV3QmFja2VuZCogcHRyKQoreworICAgIGlmIChwdHIpCisgICAgICAgIHdlYmtpdFdl YlZpZXdCYWNrZW5kVW5yZWYocHRyKTsKK30KKworfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQVBJL3dwZS9XZWJLaXRXZWJWaWV3QmFja2VuZFByaXZhdGUuaCBiL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvV2ViS2l0V2ViVmlld0JhY2tlbmRQcml2YXRlLmgK aW5kZXggYThlNDUxYjMxNzBjOWJmYzg3NjE1YzBmY2E2MzkxYzU1ZmM1MWI5Yy4uZDhkNjVlOGQ2 MWRlZTE4MzZjNTQ3ZGM3Yjg0ZjE3MjE3MDcwYjdkNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQVBJL3dwZS9XZWJLaXRXZWJWaWV3QmFja2VuZFByaXZhdGUuaAorKysgYi9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvd3BlL1dlYktpdFdlYlZpZXdCYWNrZW5kUHJpdmF0 ZS5oCkBAIC0yMSw1ICsyMSwxNCBAQAogCiAjaW5jbHVkZSAiV2ViS2l0V2ViVmlld0JhY2tlbmQu aCIKIAorI2luY2x1ZGUgPHd0Zi9nbGliL0dSZWZQdHIuaD4KKworbmFtZXNwYWNlIFdURiB7CisK K3RlbXBsYXRlIDw+IFdlYktpdFdlYlZpZXdCYWNrZW5kKiByZWZHUHRyKFdlYktpdFdlYlZpZXdC YWNrZW5kKiBwdHIpOwordGVtcGxhdGUgPD4gdm9pZCBkZXJlZkdQdHIoV2ViS2l0V2ViVmlld0Jh Y2tlbmQqIHB0cik7CisKK30KKwogdm9pZCB3ZWJraXRXZWJWaWV3QmFja2VuZFVucmVmKFdlYktp dFdlYlZpZXdCYWNrZW5kKik7Ci1XZWJLaXRXZWJWaWV3QmFja2VuZCogd2Via2l0V2ViVmlld0Jh Y2tlbmRDcmVhdGVEZWZhdWx0KCk7CitHUmVmUHRyPFdlYktpdFdlYlZpZXdCYWNrZW5kPiB3ZWJr aXRXZWJWaWV3QmFja2VuZENyZWF0ZURlZmF1bHQoKTsK