79499 2012-02-24 09:15:55 -0800 [GTK] Add support for nested event loops in RunLoop 2012-02-28 15:45:13 -0800 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED Gtk P2 Normal --- 79496 79500 1 mario mario cgarcia mrobinson pnormand oldest_to_newest 564368 0 mario 2012-02-24 09:15:55 -0800 This is something needed for properly implementing modal dialogs in WebKit2 at least, and something that other ports (e.g. Qt, Mac) already have, so it would be a good addition. Actually, it would be more than just "a good addition" but something needed if we want to implement modal dialogs in WebKit2GTK+, since I have observed (while working in the patch for modal dialogs in WK2GTK) that it would be very hard (impossible?) to implement proper unit tests for such a patch since the WebProcess would die right after closing the modal dialog, since WebCore would quit the only event loop once the dialog was closed, which would result in the WebProcess being terminated, causing great trouble and pain in the form of the unit tests hanging after that. So, a patch would be nice here. 564375 1 128747 mario 2012-02-24 09:21:02 -0800 Created attachment 128747 Patch Proposal This patch mimics the implementation for the Qt port, and works pretty nice with the patch I already have in my local machine for supporting modal dialogs in WebKit2GTK+ (that will serve as the test for this, actually). I will be reporting here the bug for the modal dialogs in WK2GTK as soon as I filed it (in a few minutes) 564376 2 mario 2012-02-24 09:22:08 -0800 This patch is written assuming we have support for GMainLoop in GRefPtr, so that's why I'm setting it as depending on bug 79496 564400 3 128747 mrobinson 2012-02-24 09:53:37 -0800 Comment on attachment 128747 Patch Proposal View in context: https://bugs.webkit.org/attachment.cgi?id=128747&action=review One thing that worries me about this patch is that RunLoop::mainLoop will return the wrong GMainLoop when you are in an interior loop. Perhapsm_runLoopMain should be replaced with a stack of loops? > Source/WebCore/platform/gtk/RunLoopGtk.cpp:50 > +static GRefPtr<GMainLoop> currentEventLoop; I think this should be a member of RunLoop. Isn't it important that this can be used across different threads? You should probably call this currentMainLoop to match the type. > Source/WebCore/platform/gtk/RunLoopGtk.cpp:55 > + static bool mainEventLoopIsRunning = false; > + if (!mainEventLoopIsRunning) { mainEventLoopIsRunning can be replaced with a call to g_main_loop_is_running. 565561 4 129009 mario 2012-02-27 04:05:28 -0800 Created attachment 129009 Patch Proposal (In reply to comment #3) > (From update of attachment 128747 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=128747&action=review > > One thing that worries me about this patch is that RunLoop::mainLoop will return the wrong GMainLoop when you are in an interior loop. Perhapsm_runLoopMain should be replaced with a stack of loops? As I said in a previous comment, I just took Qt's implementation as an example and translated it to Gtk+. Still, I agree with you there might be issues with this approach and so the idea of having a stack of loops sounds good to me too, so here it's a new patch implementing that approach. Also, I renamed RunLoop::mainLoop() to RunLoop::rootMainLoop() to make clear that it will return always the initial main loop (the one created on object construction), which is what we need to make sure it's running before attempting to create a new and nested loop. > > Source/WebCore/platform/gtk/RunLoopGtk.cpp:50 > > +static GRefPtr<GMainLoop> currentEventLoop; > > I think this should be a member of RunLoop. Isn't it important that this can be used across different threads? You should probably call this currentMainLoop to match the type. I just removed this variable now that I hold a Vector of main loops per instance of the RunLoop class. We could add a new RunLoop::currentMainLoop() to get the last one in the stack, but the truth is that I don't see it necessary at all (see the patch). > > Source/WebCore/platform/gtk/RunLoopGtk.cpp:55 > > + static bool mainEventLoopIsRunning = false; > > + if (!mainEventLoopIsRunning) { > > mainEventLoopIsRunning can be replaced with a call to g_main_loop_is_running. Very true. Fixed 565684 5 129009 mrobinson 2012-02-27 08:49:20 -0800 Comment on attachment 129009 Patch Proposal View in context: https://bugs.webkit.org/attachment.cgi?id=129009&action=review With a one small fix and a rename, this looks good to me. > Source/WebCore/platform/gtk/RunLoopGtk.cpp:54 > + for (size_t i = 0; i < m_runLoopMainLoops.size(); ++i) { > + if (!g_main_loop_is_running(m_runLoopMainLoops[i].get())) > + continue; > + g_main_loop_quit(m_runLoopMainLoops[i].get()); > + } You should probably traverse the list backward since if a loop > 1 is running, the ones before it are running too. > Source/WebCore/platform/gtk/RunLoopGtk.cpp:75 > +GMainLoop* RunLoop::rootMainLoop() I think I prefer the name innermostRunLoop. Would you mind changing this before landing. 565694 6 129009 cgarcia 2012-02-27 08:57:37 -0800 Comment on attachment 129009 Patch Proposal View in context: https://bugs.webkit.org/attachment.cgi?id=129009&action=review > Source/WebCore/platform/gtk/RunLoopGtk.cpp:72 > + GDK_THREADS_ENTER(); > + g_main_loop_run(nestedMainLoop); > + GDK_THREADS_LEAVE(); I don't think we should add this here. Note that RunLoop might be used to create run loops on any thread, that's why there's main() and current() static methods. So this can be used by a thread that doesn't even use GDK at all. So, I think the user should decide whether to use GDK_THREADS_ENTER/LEAVE, the UI process in the case of showModalDialog() 565698 7 cgarcia 2012-02-27 09:00:50 -0800 Sorry, I didn't meant to change the review flag 565705 8 129009 cgarcia 2012-02-27 09:04:29 -0800 Comment on attachment 129009 Patch Proposal View in context: https://bugs.webkit.org/attachment.cgi?id=129009&action=review >> Source/WebCore/platform/gtk/RunLoopGtk.cpp:72 >> + GDK_THREADS_LEAVE(); > > I don't think we should add this here. Note that RunLoop might be used to create run loops on any thread, that's why there's main() and current() static methods. So this can be used by a thread that doesn't even use GDK at all. So, I think the user should decide whether to use GDK_THREADS_ENTER/LEAVE, the UI process in the case of showModalDialog() Also, once the main loop has finished, you don't want to keep it in the vector, just remove it here 565706 9 129009 mrobinson 2012-02-27 09:04:38 -0800 Comment on attachment 129009 Patch Proposal View in context: https://bugs.webkit.org/attachment.cgi?id=129009&action=review >> Source/WebCore/platform/gtk/RunLoopGtk.cpp:72 >> + GDK_THREADS_LEAVE(); > > I don't think we should add this here. Note that RunLoop might be used to create run loops on any thread, that's why there's main() and current() static methods. So this can be used by a thread that doesn't even use GDK at all. So, I think the user should decide whether to use GDK_THREADS_ENTER/LEAVE, the UI process in the case of showModalDialog() I think I agree with cgarcia here. Do you mind removing these before landing? 565708 10 mrobinson 2012-02-27 09:06:15 -0800 (In reply to comment #8) > Also, once the main loop has finished, you don't want to keep it in the vector, just remove it here Presumably at that time ::stop has already been called and it's already removed... 565713 11 cgarcia 2012-02-27 09:10:27 -0800 (In reply to comment #10) > (In reply to comment #8) > > > Also, once the main loop has finished, you don't want to keep it in the vector, just remove it here > > Presumably at that time ::stop has already been called and it's already removed... But here you have already checked it's not the main one, so that in stop you can simply call main_loop_quit, and you don't need to check whether vector size is > 1. 565722 12 mrobinson 2012-02-27 09:19:34 -0800 (In reply to comment #11) > (In reply to comment #10) > > (In reply to comment #8) > > > > > Also, once the main loop has finished, you don't want to keep it in the vector, just remove it here > > > > Presumably at that time ::stop has already been called and it's already removed... > > But here you have already checked it's not the main one, so that in stop you can simply call main_loop_quit, and you don't need to check whether vector size is > 1. Good point. It does seem a bit cleaner to do that here rather than in ::stop. 566478 13 mario 2012-02-28 00:56:07 -0800 Thank you Carlos and Martin for reviewing the patches. I will apply all the suggestions before landing, but before I need to get patch for bug 79496 reviewed too. So... "ping, reviewers"? :-) 567125 14 mario 2012-02-28 14:50:20 -0800 (In reply to comment #12) >[...] > > But here you have already checked it's not the main one, so that in stop you can simply call main_loop_quit, and you don't need to check whether vector size is > 1. > > Good point. It does seem a bit cleaner to do that here rather than in ::stop. There's a problem with this: RunLoop::run() function is static, thus I don't have access to the m_runLoopMainLoops Vector there and I'd need a removeLoastMainLoop function in a similar way I needed addNestedMainLoop(). That's why I do it in the stop function: I just quit the main loop and remove it from the Vector. I think it's equivalent and more clean, since ::stop is not an static function, and so I have access to the private Vector from there. 567131 15 mrobinson 2012-02-28 14:59:02 -0800 (In reply to comment #14) > There's a problem with this: RunLoop::run() function is static, thus I don't have access to the m_runLoopMainLoops Vector there and I'd need a removeLoastMainLoop function in a similar way I needed addNestedMainLoop(). A pair of functions sounds reasonable. Why not rename addNestedMainLoop(...) to pushNestedMainLoop and then add popNestedMainLoop. It's more obvious what they do then. 567133 16 mario 2012-02-28 15:01:41 -0800 (In reply to comment #15) > (In reply to comment #14) > > > There's a problem with this: RunLoop::run() function is static, thus I don't have access to the m_runLoopMainLoops Vector there and I'd need a removeLoastMainLoop function in a similar way I needed addNestedMainLoop(). > > A pair of functions sounds reasonable. Why not rename addNestedMainLoop(...) to pushNestedMainLoop and then add popNestedMainLoop. It's more obvious what they do then. I just tried to minimize the number of new functions to add, but this idea of push and pop sounds good to me too. Will change before landing then. Thanks 567178 17 mario 2012-02-28 15:45:13 -0800 Committed r109161: <http://trac.webkit.org/changeset/109161> 128747 2012-02-24 09:21:02 -0800 2012-02-27 04:05:28 -0800 Patch Proposal 0001-2012-02-24-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 3231 mario RnJvbSA4ZjY4YjkwMjQxOTM0NmQ3ZTZjNGRjYTM4N2U0YmJkY2NjNWM4MTU5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBGcmksIDI0IEZlYiAyMDEyIDE3OjU0OjIyICswMTAwClN1YmplY3Q6IFtQQVRD SF0gMjAxMi0wMi0yNCAgTWFyaW8gU2FuY2hleiBQcmFkYSAgPG1zYW5jaGV6QGlnYWxpYS5jb20+ CgogICAgICAgIFtHVEtdIEFkZCBzdXBwb3J0IGZvciBuZXN0ZWQgZXZlbnQgbG9vcHMgaW4gUnVu TG9vcAogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03OTQ5 OQoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgUnVuIGEgbmV3 IG5lc3RlZCBtYWlubG9vcCBpZiB0aGUgbWFpbiBldmVudCBsb29wIGlzIGFscmVhZHkKICAgICAg ICBydW5uaW5nIHdoZW4gY2FsbGluZyB0byBSdW5Mb29wOjpydW4oKSwgYW5kIHRha2UgY2FyZSBv ZiBzdG9wcGluZwogICAgICAgIHRoZSByaWdodCBtYWluIGxvb3AgdG9vIHdoZW4gUnVuTG9vcDo6 c3RvcCgpIGlzIGludm9rZWQuCgogICAgICAgICogcGxhdGZvcm0vZ3RrL1J1bkxvb3BHdGsuY3Bw OgogICAgICAgIChXZWJDb3JlKToKICAgICAgICAoV2ViQ29yZTo6UnVuTG9vcDo6cnVuKToKICAg ICAgICAoV2ViQ29yZTo6UnVuTG9vcDo6c3RvcCk6Ci0tLQogU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nICAgICAgICAgICAgICAgICAgIHwgICAxNiArKysrKysrKysrKysrKysrCiBTb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvUnVuTG9vcEd0ay5jcHAgfCAgIDIzICsrKysrKysrKysrKysrKysr KysrKy0tCiAyIGZpbGVzIGNoYW5nZWQsIDM3IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0p CgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nCmluZGV4IGIxZTg4NDYuLjdmNWU3NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsNSArMSwy MSBAQAogMjAxMi0wMi0yNCAgTWFyaW8gU2FuY2hleiBQcmFkYSAgPG1zYW5jaGV6QGlnYWxpYS5j b20+CiAKKyAgICAgICAgW0dUS10gQWRkIHN1cHBvcnQgZm9yIG5lc3RlZCBldmVudCBsb29wcyBp biBSdW5Mb29wCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD03OTQ5OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFJ1biBhIG5ldyBuZXN0ZWQgbWFpbmxvb3AgaWYgdGhlIG1haW4gZXZlbnQgbG9vcCBpcyBhbHJl YWR5CisgICAgICAgIHJ1bm5pbmcgd2hlbiBjYWxsaW5nIHRvIFJ1bkxvb3A6OnJ1bigpLCBhbmQg dGFrZSBjYXJlIG9mIHN0b3BwaW5nCisgICAgICAgIHRoZSByaWdodCBtYWluIGxvb3AgdG9vIHdo ZW4gUnVuTG9vcDo6c3RvcCgpIGlzIGludm9rZWQuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsv UnVuTG9vcEd0ay5jcHA6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlJ1 bkxvb3A6OnJ1bik6CisgICAgICAgIChXZWJDb3JlOjpSdW5Mb29wOjpzdG9wKToKKworMjAxMi0w Mi0yNCAgTWFyaW8gU2FuY2hleiBQcmFkYSAgPG1zYW5jaGV6QGlnYWxpYS5jb20+CisKICAgICAg ICAgW0dUS10gQWRkIEdNYWluTG9vcCBhbmQgR01haW5Db250ZXh0IHRvIGJlIGhhbmRsZWQgYnkg R1JlZlB0cgogICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 Nzk0OTYKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1J1bkxvb3BH dGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1J1bkxvb3BHdGsuY3BwCmluZGV4 IGZiMmRmNjUuLjEyY2FhOGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9SdW5Mb29wR3RrLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUnVuTG9v cEd0ay5jcHAKQEAgLTI3LDYgKzI3LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRl ICJSdW5Mb29wLmgiCiAKKyNpbmNsdWRlIDxnZGsvZ2RrLmg+CiAjaW5jbHVkZSA8Z2xpYi5oPgog I2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KIApAQCAtNDYsOSArNDcsMjQgQEAgUnVu TG9vcDo6flJ1bkxvb3AoKQogICAgICAgICBnX21haW5fbG9vcF9xdWl0KG1fcnVuTG9vcE1haW4u Z2V0KCkpOwogfQogCitzdGF0aWMgR1JlZlB0cjxHTWFpbkxvb3A+IGN1cnJlbnRFdmVudExvb3A7 CisKIHZvaWQgUnVuTG9vcDo6cnVuKCkKIHsKLSAgICBnX21haW5fbG9vcF9ydW4oUnVuTG9vcDo6 bWFpbigpLT5tYWluTG9vcCgpKTsKKyAgICBzdGF0aWMgYm9vbCBtYWluRXZlbnRMb29wSXNSdW5u aW5nID0gZmFsc2U7CisgICAgaWYgKCFtYWluRXZlbnRMb29wSXNSdW5uaW5nKSB7CisgICAgICAg IG1haW5FdmVudExvb3BJc1J1bm5pbmcgPSB0cnVlOworICAgICAgICBnX21haW5fbG9vcF9ydW4o UnVuTG9vcDo6bWFpbigpLT5tYWluTG9vcCgpKTsKKyAgICAgICAgbWFpbkV2ZW50TG9vcElzUnVu bmluZyA9IGZhbHNlOworICAgIH0gZWxzZSB7CisgICAgICAgIGN1cnJlbnRFdmVudExvb3AgPSBh ZG9wdEdSZWYoZ19tYWluX2xvb3BfbmV3KDAsIEZBTFNFKSk7CisKKyAgICAgICAgR0RLX1RIUkVB RFNfRU5URVIoKTsKKyAgICAgICAgZ19tYWluX2xvb3BfcnVuKGN1cnJlbnRFdmVudExvb3AuZ2V0 KCkpOworICAgICAgICBHREtfVEhSRUFEU19MRUFWRSgpOworCisgICAgICAgIGN1cnJlbnRFdmVu dExvb3AuY2xlYXIoKTsKKyAgICB9CiB9CiAKIEdNYWluTG9vcCogUnVuTG9vcDo6bWFpbkxvb3Ao KQpAQCAtNTgsNyArNzQsMTAgQEAgR01haW5Mb29wKiBSdW5Mb29wOjptYWluTG9vcCgpCiAKIHZv aWQgUnVuTG9vcDo6c3RvcCgpCiB7Ci0gICAgZ19tYWluX2xvb3BfcXVpdChtX3J1bkxvb3BNYWlu LmdldCgpKTsKKyAgICBpZiAoY3VycmVudEV2ZW50TG9vcCkKKyAgICAgICAgZ19tYWluX2xvb3Bf cXVpdChjdXJyZW50RXZlbnRMb29wLmdldCgpKTsKKyAgICBlbHNlCisgICAgICAgIGdfbWFpbl9s b29wX3F1aXQobV9ydW5Mb29wTWFpbi5nZXQoKSk7CiB9CiAKIGdib29sZWFuIFJ1bkxvb3A6OnF1 ZXVlV29yayhSdW5Mb29wKiBydW5Mb29wKQotLSAKMS43LjcuNQoK 129009 2012-02-27 04:05:28 -0800 2012-02-27 09:04:38 -0800 Patch Proposal 0001-GTK-Add-support-for-nested-event-loops-in-RunLoop.patch text/plain 5563 mario RnJvbSA3Mzk2YTk1ZDNkOTU3YmRmZDJhMGQ1YmE4NWUwOGI2NWUzYjMzZWUzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBNb24sIDI3IEZlYiAyMDEyIDEwOjI3OjQ0ICswMTAwClN1YmplY3Q6IFtQQVRD SF0gW0dUS10gQWRkIHN1cHBvcnQgZm9yIG5lc3RlZCBldmVudCBsb29wcyBpbiBSdW5Mb29wCiBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Nzk0OTkKClJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgoKUnVuIGEgbmV3IG5lc3RlZCBtYWlubG9vcCBpZiB0aGUgbWFpbiBl dmVudCBsb29wIGlzIGFscmVhZHkKcnVubmluZyB3aGVuIGNhbGxpbmcgdG8gUnVuTG9vcDo6cnVu KCksIGFuZCB0YWtlIGNhcmUgb2Ygc3RvcHBpbmcKdGhlIHJpZ2h0IG1haW4gbG9vcCB0b28gd2hl biBSdW5Mb29wOjpzdG9wKCkgaXMgaW52b2tlZC4KCiogcGxhdGZvcm0vUnVuTG9vcC5oOgooUnVu TG9vcCk6CiogcGxhdGZvcm0vZ3RrL1J1bkxvb3BHdGsuY3BwOgooV2ViQ29yZTo6UnVuTG9vcDo6 UnVuTG9vcCk6CihXZWJDb3JlOjpSdW5Mb29wOjp+UnVuTG9vcCk6CihXZWJDb3JlOjpSdW5Mb29w OjpydW4pOgooV2ViQ29yZSk6CihXZWJDb3JlOjpSdW5Mb29wOjpyb290TWFpbkxvb3ApOgooV2Vi Q29yZTo6UnVuTG9vcDo6YWRkTmVzdGVkTWFpbkxvb3ApOgooV2ViQ29yZTo6UnVuTG9vcDo6c3Rv cCk6Ci0tLQogU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgIHwgICAy MiArKysrKysrKysrKwogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUnVuTG9vcC5oICAgICAgICAg IHwgICAgNSArKy0KIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9SdW5Mb29wR3RrLmNwcCB8 ICAgNTMgKysrKysrKysrKysrKysrKysrKysrKystLS0tCiAzIGZpbGVzIGNoYW5nZWQsIDcwIGlu c2VydGlvbnMoKyksIDEwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAxOGZmNWU1Li44MTky ODY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMjcgQEAKIDIwMTItMDItMjcgIE1hcmlvIFNhbmNo ZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgogCisgICAgICAgIFtHVEtdIEFkZCBzdXBw b3J0IGZvciBuZXN0ZWQgZXZlbnQgbG9vcHMgaW4gUnVuTG9vcAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Nzk0OTkKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSdW4gYSBuZXcgbmVzdGVkIG1haW5sb29wIGlm IHRoZSBtYWluIGV2ZW50IGxvb3AgaXMgYWxyZWFkeQorICAgICAgICBydW5uaW5nIHdoZW4gY2Fs bGluZyB0byBSdW5Mb29wOjpydW4oKSwgYW5kIHRha2UgY2FyZSBvZiBzdG9wcGluZworICAgICAg ICB0aGUgcmlnaHQgbWFpbiBsb29wIHRvbyB3aGVuIFJ1bkxvb3A6OnN0b3AoKSBpcyBpbnZva2Vk LgorCisgICAgICAgICogcGxhdGZvcm0vUnVuTG9vcC5oOgorICAgICAgICAoUnVuTG9vcCk6Cisg ICAgICAgICogcGxhdGZvcm0vZ3RrL1J1bkxvb3BHdGsuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 UnVuTG9vcDo6UnVuTG9vcCk6CisgICAgICAgIChXZWJDb3JlOjpSdW5Mb29wOjp+UnVuTG9vcCk6 CisgICAgICAgIChXZWJDb3JlOjpSdW5Mb29wOjpydW4pOgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgIChXZWJDb3JlOjpSdW5Mb29wOjpyb290TWFpbkxvb3ApOgorICAgICAgICAoV2ViQ29y ZTo6UnVuTG9vcDo6YWRkTmVzdGVkTWFpbkxvb3ApOgorICAgICAgICAoV2ViQ29yZTo6UnVuTG9v cDo6c3RvcCk6CisKKzIwMTItMDItMjcgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBp Z2FsaWEuY29tPgorCiAgICAgICAgIFtHVEtdIEFkZCBHTWFpbkxvb3AgYW5kIEdNYWluQ29udGV4 dCB0byBiZSBoYW5kbGVkIGJ5IEdSZWZQdHIKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTc5NDk2CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL1J1bkxvb3AuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1J1bkxvb3AuaAppbmRl eCAwZGRhYTQ4Li40OTNlMDAxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9S dW5Mb29wLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUnVuTG9vcC5oCkBAIC0xNTUs MTAgKzE1NSwxMSBAQCBwcml2YXRlOgogI2VsaWYgUExBVEZPUk0oR1RLKQogcHVibGljOgogICAg IHN0YXRpYyBnYm9vbGVhbiBxdWV1ZVdvcmsoUnVuTG9vcCopOwotICAgIEdNYWluTG9vcCogbWFp bkxvb3AoKTsKKyAgICBHTWFpbkxvb3AqIHJvb3RNYWluTG9vcCgpOworICAgIHZvaWQgYWRkTmVz dGVkTWFpbkxvb3AoR01haW5Mb29wKik7CiBwcml2YXRlOgogICAgIEdSZWZQdHI8R01haW5Db250 ZXh0PiBtX3J1bkxvb3BDb250ZXh0OwotICAgIEdSZWZQdHI8R01haW5Mb29wPiBtX3J1bkxvb3BN YWluOworICAgIFZlY3RvcjxHUmVmUHRyPEdNYWluTG9vcD4gPiBtX3J1bkxvb3BNYWluTG9vcHM7 CiAjZW5kaWYKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9S dW5Mb29wR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9SdW5Mb29wR3RrLmNw cAppbmRleCBlM2JlYTJiLi45ZDJkZjkwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvUnVuTG9vcEd0ay5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L1J1bkxvb3BHdGsuY3BwCkBAIC0yNyw2ICsyNyw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAj aW5jbHVkZSAiUnVuTG9vcC5oIgogCisjaW5jbHVkZSA8Z2RrL2dkay5oPgogI2luY2x1ZGUgPGds aWIuaD4KICNpbmNsdWRlIDx3dGYvZ29iamVjdC9HUmVmUHRyLmg+CiAKQEAgLTM3LDI5ICszOCw2 NSBAQCBSdW5Mb29wOjpSdW5Mb29wKCkKICAgICAvLyBnX21haW5fY29udGV4dF9kZWZhdWx0KCkg ZG9lc24ndCBhZGQgYW4gZXh0cmEgcmVmZXJlbmNlLgogICAgIG1fcnVuTG9vcENvbnRleHQgPSBn X21haW5fY29udGV4dF9kZWZhdWx0KCk7CiAgICAgQVNTRVJUKG1fcnVuTG9vcENvbnRleHQpOwot ICAgIG1fcnVuTG9vcE1haW4gPSBhZG9wdEdSZWYoZ19tYWluX2xvb3BfbmV3KG1fcnVuTG9vcENv bnRleHQuZ2V0KCksIEZBTFNFKSk7Ci0gICAgQVNTRVJUKG1fcnVuTG9vcE1haW4pOworICAgIEdS ZWZQdHI8R01haW5Mb29wPiByb290TWFpbkxvb3AgPSBhZG9wdEdSZWYoZ19tYWluX2xvb3BfbmV3 KG1fcnVuTG9vcENvbnRleHQuZ2V0KCksIEZBTFNFKSk7CisgICAgQVNTRVJUKHJvb3RNYWluTG9v cCk7CisgICAgbV9ydW5Mb29wTWFpbkxvb3BzLmFwcGVuZChyb290TWFpbkxvb3ApOwogfQogCiBS dW5Mb29wOjp+UnVuTG9vcCgpCiB7Ci0gICAgaWYgKG1fcnVuTG9vcE1haW4gJiYgZ19tYWluX2xv b3BfaXNfcnVubmluZyhtX3J1bkxvb3BNYWluLmdldCgpKSkKLSAgICAgICAgZ19tYWluX2xvb3Bf cXVpdChtX3J1bkxvb3BNYWluLmdldCgpKTsKKyAgICAvLyBUaGUgcm9vdCBtYWluIGxvb3Agc2hv dWxkIGFsd2F5cyBiZSB0aGVyZS4KKyAgICBBU1NFUlQoIW1fcnVuTG9vcE1haW5Mb29wcy5pc0Vt cHR5KCkpOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9ydW5Mb29wTWFpbkxvb3BzLnNp emUoKTsgKytpKSB7CisgICAgICAgIGlmICghZ19tYWluX2xvb3BfaXNfcnVubmluZyhtX3J1bkxv b3BNYWluTG9vcHNbaV0uZ2V0KCkpKQorICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIGdf bWFpbl9sb29wX3F1aXQobV9ydW5Mb29wTWFpbkxvb3BzW2ldLmdldCgpKTsKKyAgICB9CiB9CiAK IHZvaWQgUnVuTG9vcDo6cnVuKCkKIHsKLSAgICBnX21haW5fbG9vcF9ydW4oUnVuTG9vcDo6bWFp bigpLT5tYWluTG9vcCgpKTsKKyAgICBSdW5Mb29wKiBtYWluUnVuTG9vcCA9IFJ1bkxvb3A6Om1h aW4oKTsKKyAgICBHTWFpbkxvb3AqIHJvb3RNYWluTG9vcCA9IG1haW5SdW5Mb29wLT5yb290TWFp bkxvb3AoKTsKKyAgICBpZiAoIWdfbWFpbl9sb29wX2lzX3J1bm5pbmcocm9vdE1haW5Mb29wKSkg eworICAgICAgICBnX21haW5fbG9vcF9ydW4ocm9vdE1haW5Mb29wKTsKKyAgICAgICAgcmV0dXJu OworICAgIH0KKworICAgIC8vIENyZWF0ZSBhbmQgcnVuIGEgbmVzdGVkIGxvb3AgaWYgdGhlIHJv b3Qgb25lIHdhcyBhbHJlYWR5IHJ1bm5pbmcuCisgICAgR01haW5Mb29wKiBuZXN0ZWRNYWluTG9v cCA9IGdfbWFpbl9sb29wX25ldygwLCBGQUxTRSk7CisgICAgbWFpblJ1bkxvb3AtPmFkZE5lc3Rl ZE1haW5Mb29wKG5lc3RlZE1haW5Mb29wKTsKKworICAgIEdES19USFJFQURTX0VOVEVSKCk7Cisg ICAgZ19tYWluX2xvb3BfcnVuKG5lc3RlZE1haW5Mb29wKTsKKyAgICBHREtfVEhSRUFEU19MRUFW RSgpOworfQorCitHTWFpbkxvb3AqIFJ1bkxvb3A6OnJvb3RNYWluTG9vcCgpCit7CisgICAgLy8g VGhlIHJvb3QgbWFpbiBsb29wIHNob3VsZCBhbHdheXMgYmUgdGhlcmUuCisgICAgQVNTRVJUKCFt X3J1bkxvb3BNYWluTG9vcHMuaXNFbXB0eSgpKTsKKyAgICByZXR1cm4gbV9ydW5Mb29wTWFpbkxv b3BzWzBdLmdldCgpOwogfQogCi1HTWFpbkxvb3AqIFJ1bkxvb3A6Om1haW5Mb29wKCkKK3ZvaWQg UnVuTG9vcDo6YWRkTmVzdGVkTWFpbkxvb3AoR01haW5Mb29wKiBuZXN0ZWRMb29wKQogewotICAg IHJldHVybiBtX3J1bkxvb3BNYWluLmdldCgpOworICAgIC8vIFRoZSByb290IG1haW4gbG9vcCBz aG91bGQgYWx3YXlzIGJlIHRoZXJlLgorICAgIEFTU0VSVCghbV9ydW5Mb29wTWFpbkxvb3BzLmlz RW1wdHkoKSk7CisgICAgbV9ydW5Mb29wTWFpbkxvb3BzLmFwcGVuZChhZG9wdEdSZWYobmVzdGVk TG9vcCkpOwogfQogCiB2b2lkIFJ1bkxvb3A6OnN0b3AoKQogewotICAgIGdfbWFpbl9sb29wX3F1 aXQobV9ydW5Mb29wTWFpbi5nZXQoKSk7CisgICAgLy8gVGhlIHJvb3QgbWFpbiBsb29wIHNob3Vs ZCBhbHdheXMgYmUgdGhlcmUuCisgICAgQVNTRVJUKCFtX3J1bkxvb3BNYWluTG9vcHMuaXNFbXB0 eSgpKTsKKyAgICBHUmVmUHRyPEdNYWluTG9vcD4gbGFzdE1haW5Mb29wID0gbV9ydW5Mb29wTWFp bkxvb3BzLmxhc3QoKTsKKyAgICBpZiAoZ19tYWluX2xvb3BfaXNfcnVubmluZyhsYXN0TWFpbkxv b3AuZ2V0KCkpKQorICAgICAgICBnX21haW5fbG9vcF9xdWl0KGxhc3RNYWluTG9vcC5nZXQoKSk7 CisKKyAgICAvLyBBdm9pZCBsb3NpbmcgdGhlIHJvb3QgbWFpbiBsb29wIGlmIHdlIHN0b3AgaXQu CisgICAgaWYgKG1fcnVuTG9vcE1haW5Mb29wcy5zaXplKCkgPiAxKQorICAgICAgICBtX3J1bkxv b3BNYWluTG9vcHMucmVtb3ZlTGFzdCgpOwogfQogCiBnYm9vbGVhbiBSdW5Mb29wOjpxdWV1ZVdv cmsoUnVuTG9vcCogcnVuTG9vcCkKLS0gCjEuNy43LjUKCg==