144824 2015-05-08 18:50:54 -0700 [GTK] WorkQueue objects are not released 2015-05-11 03:23:12 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) PC Linux RESOLVED FIXED P2 Normal --- 1 mcatanzaro mcatanzaro benjamin bfulgham cgarcia cmarcelo commit-queue mcatanzaro mrobinson zan oldest_to_newest 1093380 0 mcatanzaro 2015-05-08 18:50:54 -0700 **FAIL** WTF_WorkQueue.Simple ../../Tools/TestWebKitAPI/Tests/WTF/WorkQueue.cpp:57 Value of: initialRefCount Actual: 2 Expected: 1 This is not a bug: we need the second ref to keep the WorkQueue alive in the lambda function where the main loop runs in another thread, in WorkQueue::platformInitialize: RefPtr<WorkQueue> protector(this); m_workQueueThread = createThread(threadName, [protector] { g_main_context_push_thread_default(protector->m_eventContext.get()); g_main_loop_run(protector->m_eventLoop.get()); g_main_context_pop_thread_default(protector->m_eventContext.get()); }); Since we need to keep the WorkQueue alive in another thread, I think the only option is to change the test, not the implementation. CC Brent since he wrote this test. We could guard the reference count checks with #if !PLATFORM(GTK), or just remove the checks completely. 1093381 1 mcatanzaro 2015-05-08 18:59:57 -0700 So all of the reference count checks in this test check the initial reference count, except for this one: EXPECT_GT(queue->refCount(), 1); m_testCompleted.wait(m_lock); But that one would fail (on any platform) if each task completes prior to the assertion being run. 1093421 2 252775 mcatanzaro 2015-05-09 08:21:44 -0700 Created attachment 252775 Patch 1093427 3 252775 bfulgham 2015-05-09 09:51:35 -0700 Comment on attachment 252775 Patch It doesn't look like we have the right behavior on iOS/mac with this change. :( 1093428 4 252775 bfulgham 2015-05-09 09:53:28 -0700 Comment on attachment 252775 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=252775&action=review > Tools/TestWebKitAPI/Tests/WTF/WorkQueue.cpp:71 > + EXPECT_GT(queue->refCount(), expectedInitialRefcount); I think I originally tried to have something like this, but ran into problems with race conditions. 1093430 5 252775 bfulgham 2015-05-09 09:55:46 -0700 Comment on attachment 252775 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=252775&action=review >> Tools/TestWebKitAPI/Tests/WTF/WorkQueue.cpp:71 >> + EXPECT_GT(queue->refCount(), expectedInitialRefcount); > > I think I originally tried to have something like this, but ran into problems with race conditions. Never mind -- this might be ok. It's just clang is unhappy with the difference in sign. I think refCount has a different type (maybe size_t?) 1093433 6 mcatanzaro 2015-05-09 10:34:29 -0700 The refcount is an unsigned int, but it was being stored in a signed int local variable. I'll switch the local variable declaration to use auto instead. Hopefully that will placate clang. 1093434 7 252780 mcatanzaro 2015-05-09 10:35:52 -0700 Created attachment 252780 Patch 1093439 8 zan 2015-05-09 10:56:09 -0700 So, in WorkQueue::platformInitialize() we create a thread and pass in a lambda that captured a RefPtr<WorkQueue>, essentially ensuring it doesn't get destroyed during that thread's lifetime. In createThread() the lambda (now wrapped in std::function<>) is stored on the heap, in the NewThreadContext object. That is again accessed on the newly-created thread, in threadEntryPoint(), moving the std::function<> off the heap, deleting the NewThreadContext, and passing the thread control to said std::function<> which is now spinning the WorkQueue's m_eventLoop. The kicker is that because a reference to the WorkQueue is held on the WorkQueue-owned thread, the WorkQueue and that thread don't get destroyed when the user drops his last reference to it, as he'd expect. We also don't interrupt the main loop anywhere else but the WorkQueue destructor (well, ::platformInvalidate()). I haven't confirmed this analysis in real world, but if it's correct, we're not destroying any WorkQueue and the underlying thread that we create. 1093442 9 mrobinson 2015-05-09 13:08:52 -0700 (In reply to comment #8) > I haven't confirmed this analysis in real world, but if it's correct, we're > not destroying any WorkQueue and the underlying thread that we create. So this sounds like a memory leak, no? 1093451 10 mcatanzaro 2015-05-09 15:47:54 -0700 As a sanity check I added this to WorkQueue.cpp: #ifndef NDEBUG #include <wtf/RefCountedLeakCounter.h> #endif DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, workQueueCounter, ("WorkQueue")); Then browsed through a few pages on a debug build. We seem to be leaking everything except WorkQueues. 1093454 11 mcatanzaro 2015-05-09 15:58:27 -0700 (In reply to comment #10) > As a sanity check I added this to WorkQueue.cpp: It wasn't a good sanity check because I forgot to increment and decrement the counter in the constructor/destructor. We leak 6 WorkQueues per WebView. 1093467 12 mcatanzaro 2015-05-09 18:01:29 -0700 A solution that seems seductively simple: GRefPtr<GMainContext> eventContextProtector(m_eventContext.get()); GRefPtr<GMainLoop> mainLoopProtector(m_eventLoop.get()); m_workQueueThread = createThread(threadName, [eventContextProtector, mainLoopProtector] { g_main_context_push_thread_default(eventContextProtector.get()); g_main_loop_run(mainLoopProtector.get()); g_main_context_pop_thread_default(eventContextProtector.get()); }); Looks good to me...? This fixes the test, but only brings us down to 5 leaks per WebView, so we're still losing a bunch of threads. Aside: Is there a reason to pop the thread default main context immediately before the thread ends, Carlos? Aside: Thanks for the test, Brent. 1093512 13 cgarcia 2015-05-10 02:53:59 -0700 (In reply to comment #8) > So, in WorkQueue::platformInitialize() we create a thread and pass in a > lambda that captured a RefPtr<WorkQueue>, essentially ensuring it doesn't > get destroyed during that thread's lifetime. Yes, but that was not the original intention, see bug #140998. We wanted to make sure that the thread was detached when the work queue is destroyed before the thread body has started. Since the WorkQueue was changed to be refcounted, every source takes a reference of the workQueue, so we don't really need to keep an extra reference for the whole like of the worker thread. I think the right solution could be to go back to the first version of the patch in bug #140998. 1093516 14 cgarcia 2015-05-10 03:34:51 -0700 (In reply to comment #12) > A solution that seems seductively simple: > > GRefPtr<GMainContext> eventContextProtector(m_eventContext.get()); > GRefPtr<GMainLoop> mainLoopProtector(m_eventLoop.get()); > m_workQueueThread = createThread(threadName, [eventContextProtector, > mainLoopProtector] { > g_main_context_push_thread_default(eventContextProtector.get()); > g_main_loop_run(mainLoopProtector.get()); > g_main_context_pop_thread_default(eventContextProtector.get()); > }); > > Looks good to me...? This fixes the test, but only brings us down to 5 leaks > per WebView, so we're still losing a bunch of threads. > > Aside: Is there a reason to pop the thread default main context immediately > before the thread ends, Carlos? Actually, we don't even need to pop the context, since we push it right after creating the thread and the thread-specific context queue will be freed when the thread exits. > Aside: Thanks for the test, Brent. 1093519 15 cgarcia 2015-05-10 03:51:40 -0700 (In reply to comment #14) > (In reply to comment #12) > > A solution that seems seductively simple: > > > > GRefPtr<GMainContext> eventContextProtector(m_eventContext.get()); > > GRefPtr<GMainLoop> mainLoopProtector(m_eventLoop.get()); > > m_workQueueThread = createThread(threadName, [eventContextProtector, > > mainLoopProtector] { > > g_main_context_push_thread_default(eventContextProtector.get()); > > g_main_loop_run(mainLoopProtector.get()); > > g_main_context_pop_thread_default(eventContextProtector.get()); > > }); > > > > Looks good to me...? This fixes the test, but only brings us down to 5 leaks > > per WebView, so we're still losing a bunch of threads. > > > > Aside: Is there a reason to pop the thread default main context immediately > > before the thread ends, Carlos? > > Actually, we don't even need to pop the context, since we push it right > after creating the thread and the thread-specific context queue will be > freed when the thread exits. We could also push/pop for every task that is run in the queue, but i think it's simpler to push right after creating the queue and never pop. > > Aside: Thanks for the test, Brent. 1093520 16 252812 cgarcia 2015-05-10 04:09:01 -0700 Created attachment 252812 Patch This should fix the test and the work queue leak. 1093531 17 mcatanzaro 2015-05-10 08:37:33 -0700 Carlos, I would change the first line of your commit message: "[GTK] WorkQueue runs forever" would be more descriptive. I tried to write a test to ensure the thread actually quits, but it's hard: detaching the thread in the destructor makes it impossible to join on it to ensure it completes, and counting threads in /proc is racy without a join, so we'd have to add new API to WorkQueue to change the behavior of the destructor just for such a test... and then we're not really testing the same functionality anymore. So I think we should be content with the existing refcount test. 1093707 18 252853 cgarcia 2015-05-11 02:39:03 -0700 Created attachment 252853 Updated patch Zan pointed out that the thread could keep running forever if the work queue is released before the thread has run the main loop. This updated patch fixes that case by scheduling a main loop quit when the work queue is released before the thread has started. As Michael said, this is not easy to test, I ran some custom tests with printfs to verify the behaviour. 1093711 19 252853 zan 2015-05-11 02:50:36 -0700 Comment on attachment 252853 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=252853&action=review > Source/WTF/wtf/gtk/WorkQueueGtk.cpp:72 > if (m_eventLoop) { This check shouldn't be necessary, we ASSERT the m_eventLoop existence in the constructor and don't destroy it anywhere. 1093712 20 cgarcia 2015-05-11 02:53:58 -0700 (In reply to comment #19) > Comment on attachment 252853 [details] > Updated patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=252853&action=review > > > Source/WTF/wtf/gtk/WorkQueueGtk.cpp:72 > > if (m_eventLoop) { > > This check shouldn't be necessary, we ASSERT the m_eventLoop existence in > the constructor and don't destroy it anywhere. Yes, this is because in the past the platformInvalidate was not called by the destructor, but by invalidate method called by the user. 1093718 21 cgarcia 2015-05-11 03:12:01 -0700 I'm going to leave the checks in the end, to ensure it keeps working even if the implementation changes again and platformInvalidate is moved somewhere else. 1093722 22 cgarcia 2015-05-11 03:23:12 -0700 Committed r184072: <http://trac.webkit.org/changeset/184072> 252775 2015-05-09 08:21:44 -0700 2015-05-09 10:35:48 -0700 Patch bug-144824-20150509102025.patch text/plain 3474 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMTg0MDMzCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNzIzOGMwZjcxMGEyMmY4ZDk0ODgzNWI1ZGQ1YjkzMDA3 MzAzYTljOC4uY2U4NGIyOGQ3NDRjZmEzNjNhMDY3MDQ5YWExZmZjZGVkZmNiZDNmNCAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4 IEBACisyMDE1LTA1LTA4ICBNaWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNv bT4KKworICAgICAgICBbR1RLXSBXVEZfV29ya1F1ZXVlLlNpbXBsZSB0ZXN0IGZhaWxzIGR1ZSB0 byBhc3N1bXB0aW9ucyBhYm91dCByZWZlcmVuY2UgY291bnQKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0NDgyNAorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZSBpbml0aWFsIHJlZmNvdW50IG9mIHRoZSBX b3JrUXVldWUgb24gdGhlIEdUSyBwb3J0IGlzIGV4cGVjdGVkIHRvIGJlIDIsIHNpbmNlIGl0J3MK KyAgICAgICAgaW5jcmVtZW50ZWQgaW50ZXJuYWxseS4gQWxzbywgY2hlY2sgdG8gc2VlIHRoYXQg dGhlIGN1cnJlbnQgcmVmY291bnQgaXMgZ3JlYXRlciB0aGFuIHRoZQorICAgICAgICBleHBlY3Rl ZCBpbml0aWFsIHJlZmNvdW50IGluc2lkZSB0aGUgZGlzcGF0Y2hlZCB0YXNrcywgcmF0aGVyIHRo YW4gYWZ0ZXIgZGlzcGF0Y2hpbmcgdGhlbSwKKyAgICAgICAgdG8gY2xvc2UgYSB0ZWVuc3kgcmFj ZSBjb25kaXRpb24gaW4gdGhlIHRlc3QuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3Rz L1dURi9Xb3JrUXVldWUuY3BwOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisKIDIw MTUtMDUtMDcgIFNhbSBXZWluaWcgIDxzYW1Ad2Via2l0Lm9yZz4KIAogICAgICAgICBbQ29udGVu dCBFeHRlbnNpb25zXSBBZGQgc2ltcGxlIHRlc3RlciB0aGF0IHRha2VzIGFuIGV4dGVuc2lvbiBh bmQgY29tcGlsZXMgaXQKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RG L1dvcmtRdWV1ZS5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9Xb3JrUXVldWUu Y3BwCmluZGV4IDRiMDM1ODc3MjVhYWNkOWE3M2I2N2VlMzFiMDAwMmIwNjc5NzM1MjAuLmUyYjNk ZWNiODI2ZTJjNTUzMWUwZjg4ZjkxNWU5Y2YxZGQwOGIwYzggMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dvcmtRdWV1ZS5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XVEYvV29ya1F1ZXVlLmNwcApAQCAtMzcsNiArMzcsMTQgQEAgc3RhdGljIGNv bnN0IGNoYXIqIHNpbXBsZVRlc3RMYWJlbCA9ICJzaW1wbGVUZXN0IjsKIHN0YXRpYyBjb25zdCBj aGFyKiBsb25nVGVzdExhYmVsID0gImxvbmdUZXN0IjsKIHN0YXRpYyBjb25zdCBjaGFyKiB0aGly ZFRlc3RMYWJlbCA9ICJ0aGlyZFRlc3QiOwogc3RhdGljIGNvbnN0IGNoYXIqIGRpc3BhdGNoQWZ0 ZXJMYWJlbCA9ICJkaXNwYXRjaEFmdGVyIjsKKworI2lmIFBMQVRGT1JNKEdUSykKKy8vIEdUSyBw b3J0IHVzZXMgYW5vdGhlciByZWYgdG8ga2VlcCB0aGUgV29ya1F1ZXVlIGFsaXZlCisvLyBpbnNp ZGUgYSBsYW1iZGEgZnVuY3Rpb24gb24gYSBuZXcgdGhyZWFkLgorc3RhdGljIGNvbnN0IHVuc2ln bmVkIGV4cGVjdGVkSW5pdGlhbFJlZmNvdW50ID0gMjsKKyNlbHNlCitzdGF0aWMgY29uc3QgdW5z aWduZWQgZXhwZWN0ZWRJbml0aWFsUmVmY291bnQgPSAxOworI2VuZGlmCiAgICAgCiBURVNUKFdU Rl9Xb3JrUXVldWUsIFNpbXBsZSkKIHsKQEAgLTU0LDE4ICs2MiwyMCBAQCBURVNUKFdURl9Xb3Jr UXVldWUsIFNpbXBsZSkKIAogICAgIGF1dG8gcXVldWUgPSBXb3JrUXVldWU6OmNyZWF0ZSgiY29t LmFwcGxlLldlYktpdC5UZXN0LnNpbXBsZSIpOwogICAgIGludCBpbml0aWFsUmVmQ291bnQgPSBx dWV1ZS0+cmVmQ291bnQoKTsKLSAgICBFWFBFQ1RfRVEoMSwgaW5pdGlhbFJlZkNvdW50KTsKKyAg ICBFWFBFQ1RfRVEoZXhwZWN0ZWRJbml0aWFsUmVmY291bnQsIGluaXRpYWxSZWZDb3VudCk7CiAK ICAgICBNdXRleExvY2tlciBsb2NrZXIobV9sb2NrKTsKICAgICBxdWV1ZS0+ZGlzcGF0Y2goWyZd KHZvaWQpIHsKICAgICAgICAgbV9mdW5jdGlvbkNhbGxPcmRlci5hcHBlbmQoc2ltcGxlVGVzdExh YmVsKTsKICAgICAgICAgY2FsbGVkU2ltcGxlVGVzdCA9IHRydWU7CisgICAgICAgIEVYUEVDVF9H VChxdWV1ZS0+cmVmQ291bnQoKSwgZXhwZWN0ZWRJbml0aWFsUmVmY291bnQpOwogICAgIH0pOwog CiAgICAgcXVldWUtPmRpc3BhdGNoKFsmXSh2b2lkKSB7CiAgICAgICAgIG1fZnVuY3Rpb25DYWxs T3JkZXIuYXBwZW5kKGxvbmdUZXN0TGFiZWwpOwogICAgICAgICBzdGQ6OnRoaXNfdGhyZWFkOjpz bGVlcF9mb3Ioc3RkOjpjaHJvbm86Om5hbm9zZWNvbmRzKDEwMCkpOwogICAgICAgICBjYWxsZWRM b25nVGVzdCA9IHRydWU7CisgICAgICAgIEVYUEVDVF9HVChxdWV1ZS0+cmVmQ291bnQoKSwgZXhw ZWN0ZWRJbml0aWFsUmVmY291bnQpOwogICAgIH0pOwogCiAgICAgcXVldWUtPmRpc3BhdGNoKFsm XSh2b2lkKSB7CkBAIC03NiwxMiArODYsMTIgQEAgVEVTVChXVEZfV29ya1F1ZXVlLCBTaW1wbGUp CiAgICAgICAgIEVYUEVDVF9UUlVFKGNhbGxlZFNpbXBsZVRlc3QpOwogICAgICAgICBFWFBFQ1Rf VFJVRShjYWxsZWRMb25nVGVzdCk7CiAgICAgICAgIEVYUEVDVF9UUlVFKGNhbGxlZFRoaXJkVGVz dCk7CisKKyAgICAgICAgRVhQRUNUX0dUKHF1ZXVlLT5yZWZDb3VudCgpLCBleHBlY3RlZEluaXRp YWxSZWZjb3VudCk7CiAgICAgICAgIAogICAgICAgICBtX3Rlc3RDb21wbGV0ZWQuc2lnbmFsKCk7 CiAgICAgfSk7CiAKLSAgICBFWFBFQ1RfR1QocXVldWUtPnJlZkNvdW50KCksIDEpOwotCiAgICAg bV90ZXN0Q29tcGxldGVkLndhaXQobV9sb2NrKTsKIAogICAgIEVYUEVDVF9UUlVFKGNhbGxlZFNp bXBsZVRlc3QpOwpAQCAtMTA3LDggKzExNyw4IEBAIFRFU1QoV1RGX1dvcmtRdWV1ZSwgVHdvUXVl dWVzKQogICAgIGF1dG8gcXVldWUxID0gV29ya1F1ZXVlOjpjcmVhdGUoImNvbS5hcHBsZS5XZWJL aXQuVGVzdC50d29RdWV1ZXMxIik7CiAgICAgYXV0byBxdWV1ZTIgPSBXb3JrUXVldWU6OmNyZWF0 ZSgiY29tLmFwcGxlLldlYktpdC5UZXN0LnR3b1F1ZXVlczIiKTsKIAotICAgIEVYUEVDVF9FUSgx LCBxdWV1ZTEtPnJlZkNvdW50KCkpOwotICAgIEVYUEVDVF9FUSgxLCBxdWV1ZTItPnJlZkNvdW50 KCkpOworICAgIEVYUEVDVF9FUShleHBlY3RlZEluaXRpYWxSZWZjb3VudCwgcXVldWUxLT5yZWZD b3VudCgpKTsKKyAgICBFWFBFQ1RfRVEoZXhwZWN0ZWRJbml0aWFsUmVmY291bnQsIHF1ZXVlMi0+ cmVmQ291bnQoKSk7CiAKICAgICBNdXRleExvY2tlciBsb2NrZXIobV9sb2NrKTsKICAgICAK 252780 2015-05-09 10:35:52 -0700 2015-05-10 04:09:01 -0700 Patch bug-144824-20150509123433.patch text/plain 3575 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMTg0MDMzCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNzIzOGMwZjcxMGEyMmY4ZDk0ODgzNWI1ZGQ1YjkzMDA3 MzAzYTljOC4uN2JjOWYzZWI5M2RiMmUxZjVmZTU2ZGEwOGZjMGViYTA5NmQxN2UzYSAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4 IEBACisyMDE1LTA1LTA5ICBNaWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNv bT4KKworICAgICAgICBbR1RLXSBXVEZfV29ya1F1ZXVlLlNpbXBsZSB0ZXN0IGZhaWxzIGR1ZSB0 byBhc3N1bXB0aW9ucyBhYm91dCByZWZlcmVuY2UgY291bnQKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0NDgyNAorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZSBpbml0aWFsIHJlZmNvdW50IG9mIHRoZSBX b3JrUXVldWUgb24gdGhlIEdUSyBwb3J0IGlzIGV4cGVjdGVkIHRvIGJlIDIsIHNpbmNlIGl0J3MK KyAgICAgICAgaW5jcmVtZW50ZWQgaW50ZXJuYWxseS4gQWxzbywgY2hlY2sgdG8gc2VlIHRoYXQg dGhlIGN1cnJlbnQgcmVmY291bnQgaXMgZ3JlYXRlciB0aGFuIHRoZQorICAgICAgICBleHBlY3Rl ZCBpbml0aWFsIHJlZmNvdW50IGluc2lkZSB0aGUgZGlzcGF0Y2hlZCB0YXNrcywgcmF0aGVyIHRo YW4gYWZ0ZXIgZGlzcGF0Y2hpbmcgdGhlbSwKKyAgICAgICAgdG8gY2xvc2UgYSB0ZWVuc3kgcmFj ZSBjb25kaXRpb24gaW4gdGhlIHRlc3QuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3Rz L1dURi9Xb3JrUXVldWUuY3BwOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisKIDIw MTUtMDUtMDcgIFNhbSBXZWluaWcgIDxzYW1Ad2Via2l0Lm9yZz4KIAogICAgICAgICBbQ29udGVu dCBFeHRlbnNpb25zXSBBZGQgc2ltcGxlIHRlc3RlciB0aGF0IHRha2VzIGFuIGV4dGVuc2lvbiBh bmQgY29tcGlsZXMgaXQKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RG L1dvcmtRdWV1ZS5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9Xb3JrUXVldWUu Y3BwCmluZGV4IDRiMDM1ODc3MjVhYWNkOWE3M2I2N2VlMzFiMDAwMmIwNjc5NzM1MjAuLjdhOTg4 MGMyMTU4MjE1MjYzYjczNTg3M2IyM2MzMDI1MTQwMzhhMTQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dvcmtRdWV1ZS5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XVEYvV29ya1F1ZXVlLmNwcApAQCAtMzcsNiArMzcsMTQgQEAgc3RhdGljIGNv bnN0IGNoYXIqIHNpbXBsZVRlc3RMYWJlbCA9ICJzaW1wbGVUZXN0IjsKIHN0YXRpYyBjb25zdCBj aGFyKiBsb25nVGVzdExhYmVsID0gImxvbmdUZXN0IjsKIHN0YXRpYyBjb25zdCBjaGFyKiB0aGly ZFRlc3RMYWJlbCA9ICJ0aGlyZFRlc3QiOwogc3RhdGljIGNvbnN0IGNoYXIqIGRpc3BhdGNoQWZ0 ZXJMYWJlbCA9ICJkaXNwYXRjaEFmdGVyIjsKKworI2lmIFBMQVRGT1JNKEdUSykKKy8vIEdUSyBw b3J0IHVzZXMgYW5vdGhlciByZWYgdG8ga2VlcCB0aGUgV29ya1F1ZXVlIGFsaXZlCisvLyBpbnNp ZGUgYSBsYW1iZGEgZnVuY3Rpb24gb24gYSBuZXcgdGhyZWFkLgorc3RhdGljIGNvbnN0IHVuc2ln bmVkIGV4cGVjdGVkSW5pdGlhbFJlZmNvdW50ID0gMjsKKyNlbHNlCitzdGF0aWMgY29uc3QgdW5z aWduZWQgZXhwZWN0ZWRJbml0aWFsUmVmY291bnQgPSAxOworI2VuZGlmCiAgICAgCiBURVNUKFdU Rl9Xb3JrUXVldWUsIFNpbXBsZSkKIHsKQEAgLTUzLDE5ICs2MSwyMSBAQCBURVNUKFdURl9Xb3Jr UXVldWUsIFNpbXBsZSkKICAgICBzdGF0aWMgY29uc3QgY2hhciogdGhpcmRUZXN0TGFiZWwgPSAi dGhpcmRUZXN0IjsKIAogICAgIGF1dG8gcXVldWUgPSBXb3JrUXVldWU6OmNyZWF0ZSgiY29tLmFw cGxlLldlYktpdC5UZXN0LnNpbXBsZSIpOwotICAgIGludCBpbml0aWFsUmVmQ291bnQgPSBxdWV1 ZS0+cmVmQ291bnQoKTsKLSAgICBFWFBFQ1RfRVEoMSwgaW5pdGlhbFJlZkNvdW50KTsKKyAgICBh dXRvIGluaXRpYWxSZWZDb3VudCA9IHF1ZXVlLT5yZWZDb3VudCgpOworICAgIEVYUEVDVF9FUShl eHBlY3RlZEluaXRpYWxSZWZjb3VudCwgaW5pdGlhbFJlZkNvdW50KTsKIAogICAgIE11dGV4TG9j a2VyIGxvY2tlcihtX2xvY2spOwogICAgIHF1ZXVlLT5kaXNwYXRjaChbJl0odm9pZCkgewogICAg ICAgICBtX2Z1bmN0aW9uQ2FsbE9yZGVyLmFwcGVuZChzaW1wbGVUZXN0TGFiZWwpOwogICAgICAg ICBjYWxsZWRTaW1wbGVUZXN0ID0gdHJ1ZTsKKyAgICAgICAgRVhQRUNUX0dUKHF1ZXVlLT5yZWZD b3VudCgpLCBleHBlY3RlZEluaXRpYWxSZWZjb3VudCk7CiAgICAgfSk7CiAKICAgICBxdWV1ZS0+ ZGlzcGF0Y2goWyZdKHZvaWQpIHsKICAgICAgICAgbV9mdW5jdGlvbkNhbGxPcmRlci5hcHBlbmQo bG9uZ1Rlc3RMYWJlbCk7CiAgICAgICAgIHN0ZDo6dGhpc190aHJlYWQ6OnNsZWVwX2ZvcihzdGQ6 OmNocm9ubzo6bmFub3NlY29uZHMoMTAwKSk7CiAgICAgICAgIGNhbGxlZExvbmdUZXN0ID0gdHJ1 ZTsKKyAgICAgICAgRVhQRUNUX0dUKHF1ZXVlLT5yZWZDb3VudCgpLCBleHBlY3RlZEluaXRpYWxS ZWZjb3VudCk7CiAgICAgfSk7CiAKICAgICBxdWV1ZS0+ZGlzcGF0Y2goWyZdKHZvaWQpIHsKQEAg LTc2LDEyICs4NiwxMiBAQCBURVNUKFdURl9Xb3JrUXVldWUsIFNpbXBsZSkKICAgICAgICAgRVhQ RUNUX1RSVUUoY2FsbGVkU2ltcGxlVGVzdCk7CiAgICAgICAgIEVYUEVDVF9UUlVFKGNhbGxlZExv bmdUZXN0KTsKICAgICAgICAgRVhQRUNUX1RSVUUoY2FsbGVkVGhpcmRUZXN0KTsKKworICAgICAg ICBFWFBFQ1RfR1QocXVldWUtPnJlZkNvdW50KCksIGV4cGVjdGVkSW5pdGlhbFJlZmNvdW50KTsK ICAgICAgICAgCiAgICAgICAgIG1fdGVzdENvbXBsZXRlZC5zaWduYWwoKTsKICAgICB9KTsKIAot ICAgIEVYUEVDVF9HVChxdWV1ZS0+cmVmQ291bnQoKSwgMSk7Ci0KICAgICBtX3Rlc3RDb21wbGV0 ZWQud2FpdChtX2xvY2spOwogCiAgICAgRVhQRUNUX1RSVUUoY2FsbGVkU2ltcGxlVGVzdCk7CkBA IC0xMDcsOCArMTE3LDggQEAgVEVTVChXVEZfV29ya1F1ZXVlLCBUd29RdWV1ZXMpCiAgICAgYXV0 byBxdWV1ZTEgPSBXb3JrUXVldWU6OmNyZWF0ZSgiY29tLmFwcGxlLldlYktpdC5UZXN0LnR3b1F1 ZXVlczEiKTsKICAgICBhdXRvIHF1ZXVlMiA9IFdvcmtRdWV1ZTo6Y3JlYXRlKCJjb20uYXBwbGUu V2ViS2l0LlRlc3QudHdvUXVldWVzMiIpOwogCi0gICAgRVhQRUNUX0VRKDEsIHF1ZXVlMS0+cmVm Q291bnQoKSk7Ci0gICAgRVhQRUNUX0VRKDEsIHF1ZXVlMi0+cmVmQ291bnQoKSk7CisgICAgRVhQ RUNUX0VRKGV4cGVjdGVkSW5pdGlhbFJlZmNvdW50LCBxdWV1ZTEtPnJlZkNvdW50KCkpOworICAg IEVYUEVDVF9FUShleHBlY3RlZEluaXRpYWxSZWZjb3VudCwgcXVldWUyLT5yZWZDb3VudCgpKTsK IAogICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX2xvY2spOwogICAgIAo= 252812 2015-05-10 04:09:01 -0700 2015-05-11 02:39:03 -0700 Patch wtf-work-queue-leak.diff text/plain 3215 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cK aW5kZXggYTY1MTMzYS4uNmQxNzQzOTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTUtMDUtMTAg IENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgorCisgICAgICAgIFtH VEtdIFdURl9Xb3JrUXVldWUuU2ltcGxlIHRlc3QgZmFpbHMgZHVlIHRvIGFzc3VtcHRpb25zIGFi b3V0IHJlZmVyZW5jZSBjb3VudAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTQ0ODI0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgRG8gbm90IGtlZXAgYSByZWZlcmVuY2Ugb2YgdGhlIFdvcmtRdWV1ZSBmb3Ig dGhlIGVudGlyZSBsaWZlIG9mCisgICAgICAgIGl0cyB3b3JrZXIgdGhyZWFkLCBzaW5jZSBldmVy eSB0YXNrIHNjaGVkdWxlZCBvbiB0aGUgV29ya1F1ZXVlCisgICAgICAgIGFscmVhZHkgdGFrZXMg YSByZWZlcmVuY2UuIEluc3RlYWQsIHRha2UgYSByZWZlcmVuY2Ugb2YgdGhlIG1haW4KKyAgICAg ICAgbG9vcCB0byBtYWtlIHN1cmUgdGhhdCB3aGVuIHRoZSB3b3JrZXIgdGhyZWFkIHN0YXJ0cywg dGhlIG1haW4KKyAgICAgICAgbG9vcCBoYXNuJ3QgYmVlbiByZWxlYXNlZCB0byBhdm9pZCBydW50 aW1lIHdhcm5pbmdzIChzZWUKKyAgICAgICAgd2Via2l0Lm9yZy9iLzE0MDk5OCkuIEFsc28gcmVt b3ZlZCB0aGUgZ19tYWluX2NvbnRleHRfcG9wX3RocmVhZF9kZWZhdWx0KCkKKyAgICAgICAgZnJv bSB0aGUgdGhyZWFkIGJvZHksIHNpbmNlIHRoZSB0aHJlYWQtc3BlY2lmaWMgY29udGV4dCBxdWV1 ZSB3aWxsCisgICAgICAgIGJlIGZyZWVkIGFueXdheSB3aGVuIHRoZSB0aHJlYWQgZXhpdHMuCisK KyAgICAgICAgKiB3dGYvV29ya1F1ZXVlLmg6IFJlbW92ZSB1bnVzZWQgZXZlbnQgbG9vcCBtdXRl eC4KKyAgICAgICAgKiB3dGYvZ3RrL1dvcmtRdWV1ZUd0ay5jcHA6CisgICAgICAgIChXVEY6Oldv cmtRdWV1ZTo6cGxhdGZvcm1Jbml0aWFsaXplKToKKyAgICAgICAgKFdURjo6V29ya1F1ZXVlOjpw bGF0Zm9ybUludmFsaWRhdGUpOgorCiAyMDE1LTA1LTA5ICBZb2F2IFdlaXNzICA8eW9hdkB5b2F2 LndzPgogCiAgICAgICAgIFJlbW92ZSB0aGUgUElDVFVSRV9TSVpFUyBidWlsZCBmbGFnCmRpZmYg LS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9Xb3JrUXVldWUuaCBiL1NvdXJjZS9XVEYvd3RmL1dvcmtR dWV1ZS5oCmluZGV4IGY5ZTU3MDcuLjE1ZDc1NWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3Rm L1dvcmtRdWV1ZS5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1dvcmtRdWV1ZS5oCkBAIC0xMDYsNyAr MTA2LDYgQEAgcHJpdmF0ZToKICNlbGlmIFBMQVRGT1JNKEdUSykKICAgICBUaHJlYWRJZGVudGlm aWVyIG1fd29ya1F1ZXVlVGhyZWFkOwogICAgIEdSZWZQdHI8R01haW5Db250ZXh0PiBtX2V2ZW50 Q29udGV4dDsKLSAgICBNdXRleCBtX2V2ZW50TG9vcExvY2s7CiAgICAgR1JlZlB0cjxHTWFpbkxv b3A+IG1fZXZlbnRMb29wOwogICAgIEdNYWluTG9vcFNvdXJjZSBtX3NvY2tldEV2ZW50U291cmNl OwogI2VsaWYgUExBVEZPUk0oRUZMKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvZ3RrL1dv cmtRdWV1ZUd0ay5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9ndGsvV29ya1F1ZXVlR3RrLmNwcAppbmRl eCA0MWMwNTA5Li5iY2Y3OTg1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9ndGsvV29ya1F1 ZXVlR3RrLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9ndGsvV29ya1F1ZXVlR3RrLmNwcApAQCAt NTUsMTEgKzU1LDEwIEBAIHZvaWQgV29ya1F1ZXVlOjpwbGF0Zm9ybUluaXRpYWxpemUoY29uc3Qg Y2hhciogbmFtZSwgVHlwZSwgUU9TKQogICAgIGlmIChzdHJsZW4odGhyZWFkTmFtZSkgPiBrVmlz dWFsU3R1ZGlvVGhyZWFkTmFtZUxpbWl0KQogICAgICAgICB0aHJlYWROYW1lICs9IHN0cmxlbih0 aHJlYWROYW1lKSAtIGtWaXN1YWxTdHVkaW9UaHJlYWROYW1lTGltaXQ7CiAKLSAgICBSZWZQdHI8 V29ya1F1ZXVlPiBwcm90ZWN0b3IodGhpcyk7Ci0gICAgbV93b3JrUXVldWVUaHJlYWQgPSBjcmVh dGVUaHJlYWQodGhyZWFkTmFtZSwgW3Byb3RlY3Rvcl0gewotICAgICAgICBnX21haW5fY29udGV4 dF9wdXNoX3RocmVhZF9kZWZhdWx0KHByb3RlY3Rvci0+bV9ldmVudENvbnRleHQuZ2V0KCkpOwot ICAgICAgICBnX21haW5fbG9vcF9ydW4ocHJvdGVjdG9yLT5tX2V2ZW50TG9vcC5nZXQoKSk7Ci0g ICAgICAgIGdfbWFpbl9jb250ZXh0X3BvcF90aHJlYWRfZGVmYXVsdChwcm90ZWN0b3ItPm1fZXZl bnRDb250ZXh0LmdldCgpKTsKKyAgICBHUmVmUHRyPEdNYWluTG9vcD4gZXZlbnRMb29wKG1fZXZl bnRMb29wLmdldCgpKTsKKyAgICBtX3dvcmtRdWV1ZVRocmVhZCA9IGNyZWF0ZVRocmVhZCh0aHJl YWROYW1lLCBbZXZlbnRMb29wXSB7CisgICAgICAgIGdfbWFpbl9jb250ZXh0X3B1c2hfdGhyZWFk X2RlZmF1bHQoZ19tYWluX2xvb3BfZ2V0X2NvbnRleHQoZXZlbnRMb29wLmdldCgpKSk7CisgICAg ICAgIGdfbWFpbl9sb29wX3J1bihldmVudExvb3AuZ2V0KCkpOwogICAgIH0pOwogfQogCkBAIC03 MCwxNCArNjksMTMgQEAgdm9pZCBXb3JrUXVldWU6OnBsYXRmb3JtSW52YWxpZGF0ZSgpCiAgICAg ICAgIG1fd29ya1F1ZXVlVGhyZWFkID0gMDsKICAgICB9CiAKLSAgICBNdXRleExvY2tlciBsb2Nr ZXIobV9ldmVudExvb3BMb2NrKTsKICAgICBpZiAobV9ldmVudExvb3ApIHsKICAgICAgICAgaWYg KGdfbWFpbl9sb29wX2lzX3J1bm5pbmcobV9ldmVudExvb3AuZ2V0KCkpKQogICAgICAgICAgICAg Z19tYWluX2xvb3BfcXVpdChtX2V2ZW50TG9vcC5nZXQoKSk7Ci0gICAgICAgIG1fZXZlbnRMb29w LmNsZWFyKCk7CisgICAgICAgIG1fZXZlbnRMb29wID0gbnVsbHB0cjsKICAgICB9CiAKLSAgICBt X2V2ZW50Q29udGV4dC5jbGVhcigpOworICAgIG1fZXZlbnRDb250ZXh0ID0gbnVsbHB0cjsKIH0K IAogdm9pZCBXb3JrUXVldWU6OnJlZ2lzdGVyU29ja2V0RXZlbnRIYW5kbGVyKGludCBmaWxlRGVz Y3JpcHRvciwgc3RkOjpmdW5jdGlvbjx2b2lkICgpPiBmdW5jdGlvbiwgc3RkOjpmdW5jdGlvbjx2 b2lkICgpPiBjbG9zZUZ1bmN0aW9uKQo= 252853 2015-05-11 02:39:03 -0700 2015-05-11 02:50:36 -0700 Updated patch wk-work-queue-gtk.diff text/plain 3794 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cK aW5kZXggYTY1MTMzYS4uODM4YjBlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9DaGFuZ2VMb2cK KysrIGIvU291cmNlL1dURi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAxNS0wNS0xMSAg Q2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dU S10gV29ya1F1ZXVlIG9iamVjdHMgYXJlIG5vdCByZWxlYXNlZAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0ODI0CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRG8gbm90IGtlZXAgYSByZWZlcmVuY2Ugb2Yg dGhlIFdvcmtRdWV1ZSBmb3IgdGhlIGVudGlyZSBsaWZlIG9mCisgICAgICAgIGl0cyB3b3JrZXIg dGhyZWFkLCBzaW5jZSBldmVyeSB0YXNrIHNjaGVkdWxlZCBvbiB0aGUgV29ya1F1ZXVlCisgICAg ICAgIGFscmVhZHkgdGFrZXMgYSByZWZlcmVuY2UuIEluc3RlYWQsIHRha2UgYSByZWZlcmVuY2Ug b2YgdGhlIG1haW4KKyAgICAgICAgbG9vcCB0byBtYWtlIHN1cmUgdGhhdCB3aGVuIHRoZSB3b3Jr ZXIgdGhyZWFkIHN0YXJ0cywgdGhlIG1haW4KKyAgICAgICAgbG9vcCBoYXNuJ3QgYmVlbiByZWxl YXNlZCB0byBhdm9pZCBydW50aW1lIHdhcm5pbmdzIChzZWUKKyAgICAgICAgd2Via2l0Lm9yZy9i LzE0MDk5OCkuIEFsc28gcmVtb3ZlZCB0aGUgZ19tYWluX2NvbnRleHRfcG9wX3RocmVhZF9kZWZh dWx0KCkKKyAgICAgICAgZnJvbSB0aGUgdGhyZWFkIGJvZHksIHNpbmNlIHRoZSB0aHJlYWQtc3Bl Y2lmaWMgY29udGV4dCBxdWV1ZSB3aWxsCisgICAgICAgIGJlIGZyZWVkIGFueXdheSB3aGVuIHRo ZSB0aHJlYWQgZXhpdHMuCisgICAgICAgIElmIHRoZSBXb3JrUXVldWUgaXMgcmVsZWFzZWQgZWFy bHksIGJlZm9yZSB0aGUgdGhyZWFkIGhhcyBzdGFydGVkLAorICAgICAgICBzY2hlZHVsZSBhIG1h aW4gbG9vcCBxdWl0IGluIHRoZSBjb250ZXh0LCB0byBtYWtlIHN1cmUgaXQgd2lsbAorICAgICAg ICBiZSB0aGUgZmlyc3QgdGhpbmcgcnVuIGJ5IHRoZSBtYWluIGxvb3AgYW5kIHRoZSB0aHJlYWQg d2lsbCBleGl0LgorCisgICAgICAgICogd3RmL1dvcmtRdWV1ZS5oOiBSZW1vdmUgdW51c2VkIGV2 ZW50IGxvb3AgbXV0ZXguCisgICAgICAgICogd3RmL2d0ay9Xb3JrUXVldWVHdGsuY3BwOgorICAg ICAgICAoV1RGOjpXb3JrUXVldWU6OnBsYXRmb3JtSW5pdGlhbGl6ZSk6CisgICAgICAgIChXVEY6 OldvcmtRdWV1ZTo6cGxhdGZvcm1JbnZhbGlkYXRlKToKKwogMjAxNS0wNS0wOSAgWW9hdiBXZWlz cyAgPHlvYXZAeW9hdi53cz4KIAogICAgICAgICBSZW1vdmUgdGhlIFBJQ1RVUkVfU0laRVMgYnVp bGQgZmxhZwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvV29ya1F1ZXVlLmggYi9Tb3VyY2Uv V1RGL3d0Zi9Xb3JrUXVldWUuaAppbmRleCBmOWU1NzA3Li4xNWQ3NTVmIDEwMDY0NAotLS0gYS9T b3VyY2UvV1RGL3d0Zi9Xb3JrUXVldWUuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9Xb3JrUXVldWUu aApAQCAtMTA2LDcgKzEwNiw2IEBAIHByaXZhdGU6CiAjZWxpZiBQTEFURk9STShHVEspCiAgICAg VGhyZWFkSWRlbnRpZmllciBtX3dvcmtRdWV1ZVRocmVhZDsKICAgICBHUmVmUHRyPEdNYWluQ29u dGV4dD4gbV9ldmVudENvbnRleHQ7Ci0gICAgTXV0ZXggbV9ldmVudExvb3BMb2NrOwogICAgIEdS ZWZQdHI8R01haW5Mb29wPiBtX2V2ZW50TG9vcDsKICAgICBHTWFpbkxvb3BTb3VyY2UgbV9zb2Nr ZXRFdmVudFNvdXJjZTsKICNlbGlmIFBMQVRGT1JNKEVGTCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9X VEYvd3RmL2d0ay9Xb3JrUXVldWVHdGsuY3BwIGIvU291cmNlL1dURi93dGYvZ3RrL1dvcmtRdWV1 ZUd0ay5jcHAKaW5kZXggNDFjMDUwOS4uZWUxYjYwYiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93 dGYvZ3RrL1dvcmtRdWV1ZUd0ay5jcHAKKysrIGIvU291cmNlL1dURi93dGYvZ3RrL1dvcmtRdWV1 ZUd0ay5jcHAKQEAgLTU1LDExICs1NSwxMCBAQCB2b2lkIFdvcmtRdWV1ZTo6cGxhdGZvcm1Jbml0 aWFsaXplKGNvbnN0IGNoYXIqIG5hbWUsIFR5cGUsIFFPUykKICAgICBpZiAoc3RybGVuKHRocmVh ZE5hbWUpID4ga1Zpc3VhbFN0dWRpb1RocmVhZE5hbWVMaW1pdCkKICAgICAgICAgdGhyZWFkTmFt ZSArPSBzdHJsZW4odGhyZWFkTmFtZSkgLSBrVmlzdWFsU3R1ZGlvVGhyZWFkTmFtZUxpbWl0Owog Ci0gICAgUmVmUHRyPFdvcmtRdWV1ZT4gcHJvdGVjdG9yKHRoaXMpOwotICAgIG1fd29ya1F1ZXVl VGhyZWFkID0gY3JlYXRlVGhyZWFkKHRocmVhZE5hbWUsIFtwcm90ZWN0b3JdIHsKLSAgICAgICAg Z19tYWluX2NvbnRleHRfcHVzaF90aHJlYWRfZGVmYXVsdChwcm90ZWN0b3ItPm1fZXZlbnRDb250 ZXh0LmdldCgpKTsKLSAgICAgICAgZ19tYWluX2xvb3BfcnVuKHByb3RlY3Rvci0+bV9ldmVudExv b3AuZ2V0KCkpOwotICAgICAgICBnX21haW5fY29udGV4dF9wb3BfdGhyZWFkX2RlZmF1bHQocHJv dGVjdG9yLT5tX2V2ZW50Q29udGV4dC5nZXQoKSk7CisgICAgR1JlZlB0cjxHTWFpbkxvb3A+IGV2 ZW50TG9vcChtX2V2ZW50TG9vcC5nZXQoKSk7CisgICAgbV93b3JrUXVldWVUaHJlYWQgPSBjcmVh dGVUaHJlYWQodGhyZWFkTmFtZSwgW2V2ZW50TG9vcF0geworICAgICAgICBnX21haW5fY29udGV4 dF9wdXNoX3RocmVhZF9kZWZhdWx0KGdfbWFpbl9sb29wX2dldF9jb250ZXh0KGV2ZW50TG9vcC5n ZXQoKSkpOworICAgICAgICBnX21haW5fbG9vcF9ydW4oZXZlbnRMb29wLmdldCgpKTsKICAgICB9 KTsKIH0KIApAQCAtNzAsMTQgKzY5LDE5IEBAIHZvaWQgV29ya1F1ZXVlOjpwbGF0Zm9ybUludmFs aWRhdGUoKQogICAgICAgICBtX3dvcmtRdWV1ZVRocmVhZCA9IDA7CiAgICAgfQogCi0gICAgTXV0 ZXhMb2NrZXIgbG9ja2VyKG1fZXZlbnRMb29wTG9jayk7CiAgICAgaWYgKG1fZXZlbnRMb29wKSB7 CiAgICAgICAgIGlmIChnX21haW5fbG9vcF9pc19ydW5uaW5nKG1fZXZlbnRMb29wLmdldCgpKSkK ICAgICAgICAgICAgIGdfbWFpbl9sb29wX3F1aXQobV9ldmVudExvb3AuZ2V0KCkpOwotICAgICAg ICBtX2V2ZW50TG9vcC5jbGVhcigpOworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIC8vIFRo ZSB0aHJlYWQgaGFzbid0IHN0YXJ0ZWQgeWV0LCBzbyBzY2hlZHVsZSBhIG1haW4gbG9vcCBxdWl0 IHRvIGVuc3VyZSB0aGUgdGhyZWFkIGZpbmlzaGVzLgorICAgICAgICAgICAgR01haW5Mb29wKiBl dmVudExvb3AgPSBtX2V2ZW50TG9vcC5nZXQoKTsKKyAgICAgICAgICAgIEdNYWluTG9vcFNvdXJj ZTo6c2NoZWR1bGVBbmREZWxldGVPbkRlc3Ryb3koIltXZWJLaXRdIFdvcmtRdWV1ZSBxdWl0IG1h aW4gbG9vcCIsIFtldmVudExvb3BdIHsgZ19tYWluX2xvb3BfcXVpdChldmVudExvb3ApOyB9LAor ICAgICAgICAgICAgICAgIEdfUFJJT1JJVFlfSElHSCwgbnVsbHB0ciwgbV9ldmVudENvbnRleHQu Z2V0KCkpOworICAgICAgICB9CisgICAgICAgIG1fZXZlbnRMb29wID0gbnVsbHB0cjsKICAgICB9 CiAKLSAgICBtX2V2ZW50Q29udGV4dC5jbGVhcigpOworICAgIG1fZXZlbnRDb250ZXh0ID0gbnVs bHB0cjsKIH0KIAogdm9pZCBXb3JrUXVldWU6OnJlZ2lzdGVyU29ja2V0RXZlbnRIYW5kbGVyKGlu dCBmaWxlRGVzY3JpcHRvciwgc3RkOjpmdW5jdGlvbjx2b2lkICgpPiBmdW5jdGlvbiwgc3RkOjpm dW5jdGlvbjx2b2lkICgpPiBjbG9zZUZ1bmN0aW9uKQo=