221451 2021-02-04 21:40:51 -0800 REGRESSION(r272337): crash under WebCore::SpeechRecognizer::setInactive() 2021-02-05 16:44:14 -0800 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 sihui_liu sihui_liu webkit-bug-importer youennf oldest_to_newest 1725939 0 sihui_liu 2021-02-04 21:40:51 -0800 ... 1725940 1 sihui_liu 2021-02-04 21:43:42 -0800 0 com.apple.WebKit 0x000000010686353c WebCore::SpeechRecognizer::setInactive() + 12 (SpeechRecognizer.h:59) 1 com.apple.WebKit 0x00000001068634c0 auto WebKit::SpeechRecognitionServer::handleRequest(WTF::UniqueRef<WebCore::SpeechRecognitionRequest>&&)::$_0::operator()<WebCore::SpeechRecognitionUpdate const>(WebCore::SpeechRecognitionUpdate const&) const + 192 (SpeechRecognitionServer.cpp:104) 2 com.apple.WebKit 0x00000001068632b3 WTF::Detail::CallableWrapper<WebKit::SpeechRecognitionServer::handleRequest(WTF::UniqueRef<WebCore::SpeechRecognitionRequest>&&)::$_0, void, WebCore::SpeechRecognitionUpdate const&>::call(WebCore::SpeechRecognitionUpdate const&) + 51 (Function.h:52) 3 com.apple.WebCore 0x000000011457af3a WTF::Function<void (WebCore::SpeechRecognitionUpdate const&)>::operator()(WebCore::SpeechRecognitionUpdate const&) const + 154 (Function.h:83) 4 com.apple.WebCore 0x00000001162b3f22 WebCore::SpeechRecognizer::~SpeechRecognizer() + 130 (SpeechRecognizer.cpp:48) 5 com.apple.WebCore 0x00000001162b4065 WebCore::SpeechRecognizer::~SpeechRecognizer() + 21 (SpeechRecognizer.cpp:46) 6 com.apple.WebKit 0x0000000105d8501b std::__1::default_delete<WebCore::SpeechRecognizer>::operator()(WebCore::SpeechRecognizer*) const + 43 (memory:2368) 7 com.apple.WebKit 0x0000000105d84f9f std::__1::unique_ptr<WebCore::SpeechRecognizer, std::__1::default_delete<WebCore::SpeechRecognizer> >::reset(WebCore::SpeechRecognizer*) + 95 (memory:2623) 8 com.apple.WebKit 0x0000000105d84f39 std::__1::unique_ptr<WebCore::SpeechRecognizer, std::__1::default_delete<WebCore::SpeechRecognizer> >::~unique_ptr() + 25 (memory:2577) 9 com.apple.WebKit 0x0000000105d84bd5 std::__1::unique_ptr<WebCore::SpeechRecognizer, std::__1::default_delete<WebCore::SpeechRecognizer> >::~unique_ptr() + 21 (memory:2577) 10 com.apple.WebKit 0x0000000105d84b07 WebKit::SpeechRecognitionServer::~SpeechRecognitionServer() + 103 (SpeechRecognitionServer.h:52) 11 com.apple.WebKit 0x0000000105d84a25 WebKit::SpeechRecognitionServer::~SpeechRecognitionServer() + 21 (SpeechRecognitionServer.h:52) 12 com.apple.WebKit 0x0000000105d84a4c WebKit::SpeechRecognitionServer::~SpeechRecognitionServer() + 28 (SpeechRecognitionServer.h:52) 13 com.apple.WebKit 0x0000000106ae208f std::__1::default_delete<WebKit::SpeechRecognitionServer>::operator()(WebKit::SpeechRecognitionServer*) const + 47 (memory:2368) 14 com.apple.WebKit 0x0000000106ae204f std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> >::reset(WebKit::SpeechRecognitionServer*) + 95 (memory:2623) 15 com.apple.WebKit 0x0000000106ae20b9 std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> >::~unique_ptr() + 25 (memory:2577) 16 com.apple.WebKit 0x0000000106a6b2a5 std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> >::~unique_ptr() + 21 (memory:2577) 17 com.apple.WebKit 0x0000000106a7f04e WTF::KeyValuePair<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > >::~KeyValuePair() + 30 (KeyValuePair.h:33) 18 com.apple.WebKit 0x0000000106a7f015 WTF::KeyValuePair<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > >::~KeyValuePair() + 21 (KeyValuePair.h:33) 19 com.apple.WebKit 0x0000000106a7efa1 WTF::HashTable<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WTF::KeyValuePair<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > >, WTF::KeyValuePairKeyExtractor<WTF::KeyValuePair<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > > >, WTF::DefaultHash<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashMap<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> >, WTF::DefaultHash<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashTraits<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashTraits<std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > > >::KeyValuePairTraits, WTF::HashTraits<WTF::ObjectIdentifier<WebCore::PageIdentifierType> > >::deallocateTable(WTF::KeyValuePair<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > >*) + 97 (HashTable.h:1241) 20 com.apple.WebKit 0x0000000106a7ee66 WTF::HashTable<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WTF::KeyValuePair<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > >, WTF::KeyValuePairKeyExtractor<WTF::KeyValuePair<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > > >, WTF::DefaultHash<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashMap<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> >, WTF::DefaultHash<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashTraits<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashTraits<std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > > >::KeyValuePairTraits, WTF::HashTraits<WTF::ObjectIdentifier<WebCore::PageIdentifierType> > >::~HashTable() + 54 (HashTable.h:414) 21 com.apple.WebKit 0x0000000106a7ee25 WTF::HashTable<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WTF::KeyValuePair<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > >, WTF::KeyValuePairKeyExtractor<WTF::KeyValuePair<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > > >, WTF::DefaultHash<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashMap<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> >, WTF::DefaultHash<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashTraits<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashTraits<std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > > >::KeyValuePairTraits, WTF::HashTraits<WTF::ObjectIdentifier<WebCore::PageIdentifierType> > >::~HashTable() + 21 (HashTable.h:411) 22 com.apple.WebKit 0x0000000106a7ee05 WTF::HashMap<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> >, WTF::DefaultHash<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashTraits<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashTraits<std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > > >::~HashMap() + 21 (HashMap.h:35) 23 com.apple.WebKit 0x0000000106a5fad5 WTF::HashMap<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> >, WTF::DefaultHash<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashTraits<WTF::ObjectIdentifier<WebCore::PageIdentifierType> >, WTF::HashTraits<std::__1::unique_ptr<WebKit::SpeechRecognitionServer, std::__1::default_delete<WebKit::SpeechRecognitionServer> > > >::~HashMap() + 21 (HashMap.h:35) 24 com.apple.WebKit 0x0000000106a5f354 WebKit::WebProcessProxy::~WebProcessProxy() + 1220 (WebProcessProxy.cpp:267) 25 com.apple.WebKit 0x0000000106a5fd55 WebKit::WebProcessProxy::~WebProcessProxy() + 21 (WebProcessProxy.cpp:230) 26 com.apple.WebKit 0x0000000106a5fddc WebKit::WebProcessProxy::~WebProcessProxy() + 28 (WebProcessProxy.cpp:230) 1725951 2 419366 sihui_liu 2021-02-04 23:40:50 -0800 Created attachment 419366 Patch 1726032 3 419366 youennf 2021-02-05 06:00:22 -0800 Comment on attachment 419366 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=419366&action=review > Source/WebKit/UIProcess/SpeechRecognitionServer.cpp:98 > + return; How about storing in the lambda clientIdentifier?. Then we can simply do: if (update.clientIdentifier() != clientIdentifier). Also, do we really need to call sendUpdate before this check? It seems like we should not need to send updates if speech recognition server is no longer using the same recogniser. I would also be tempted to do something like: if (m_recognizer) { m_recognizer->abort(WebCore::SpeechRecognitionError { WebCore::SpeechRecognitionErrorType::Aborted, "Another request is started"_s }); m_recognizer = nullptr; } Also, looking at SpeechRecognizer::abort and SpeechRecognizer::stop, I do not really understand why we are going to Aborting and then waiting to send the End update in destructor. It seems it would be better to not send any update in the destructor. Couldn't we do something like: void SpeechRecognizer::abort(Optional<SpeechRecognitionError>&& error) { if (m_state == State::Aborting || m_state == State::Inactive) return; // Do we even need this one. m_state = State::Aborting; if (error) m_delegateCallback(SpeechRecognitionUpdate::createError(clientIdentifier(), *error)); stopCapture(); abortRecognition(); m_delegateCallback(SpeechRecognitionUpdate::create(clientIdentifier(), SpeechRecognitionUpdateType::End)); m_state = State::Inactive; } Ditto for stop. 1726088 4 419366 sihui_liu 2021-02-05 08:51:06 -0800 Comment on attachment 419366 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=419366&action=review >> Source/WebKit/UIProcess/SpeechRecognitionServer.cpp:98 >> + return; > > How about storing in the lambda clientIdentifier?. > Then we can simply do: > if (update.clientIdentifier() != clientIdentifier). > > Also, do we really need to call sendUpdate before this check? > It seems like we should not need to send updates if speech recognition server is no longer using the same recogniser. > > I would also be tempted to do something like: > if (m_recognizer) { > m_recognizer->abort(WebCore::SpeechRecognitionError { WebCore::SpeechRecognitionErrorType::Aborted, "Another request is started"_s }); > m_recognizer = nullptr; > } > > Also, looking at SpeechRecognizer::abort and SpeechRecognizer::stop, I do not really understand why we are going to Aborting and then waiting to send the End update in destructor. > It seems it would be better to not send any update in the destructor. > > Couldn't we do something like: > > void SpeechRecognizer::abort(Optional<SpeechRecognitionError>&& error) > { > if (m_state == State::Aborting || m_state == State::Inactive) > return; > // Do we even need this one. > m_state = State::Aborting; > > if (error) > m_delegateCallback(SpeechRecognitionUpdate::createError(clientIdentifier(), *error)); > > stopCapture(); > abortRecognition(); > m_delegateCallback(SpeechRecognitionUpdate::create(clientIdentifier(), SpeechRecognitionUpdateType::End)); > m_state = State::Inactive; > } > > Ditto for stop. Here's my thoughts: Why do we send end update in the destructor? 1) stop and abort are async: in WebSpeechRecognizerTask, we send end update when we receive SFSpeechRecognitionTaskDelegate callback. 2) we ditch current request/recognizer immediately after abort(), only if the current request is aborted because a new request is about to start (in our current implementation). 3) if recognizer is destroyed before end update and start update is sent before, we need to make sure an end update is sent to inform client the request ends so client can update state. Why do we setting State::Aborting for abort? 0) abort is async, so after abort recognizer may still be active(sending updates) until end (becoming inactive) 1) we abort the request when there is an error occurred and there can be error occurred during abort 1726207 5 419438 sihui_liu 2021-02-05 11:24:32 -0800 Created attachment 419438 Patch 1726222 6 youennf 2021-02-05 12:10:39 -0800 > Why do we setting State::Aborting for abort? > 0) abort is async, so after abort recognizer may still be active(sending > updates) until end (becoming inactive) > 1) we abort the request when there is an error occurred and there can be > error occurred during abort The typical way to do this might to add completion handlers to stop and abort. Since that would be the last update, the completion handlers could potentially take the recogniser update callback. 1726311 7 419477 sihui_liu 2021-02-05 16:03:31 -0800 Created attachment 419477 Patch for landing 1726321 8 ews-feeder 2021-02-05 16:43:26 -0800 Committed r272451: <https://trac.webkit.org/changeset/272451> All reviewed patches have been landed. Closing bug and clearing flags on attachment 419477. 1726322 9 webkit-bug-importer 2021-02-05 16:44:14 -0800 <rdar://problem/74047313> 419366 2021-02-04 23:40:50 -0800 2021-02-05 11:24:25 -0800 Patch bug-221451-20210204234049.patch text/plain 4111 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjcyNDAzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDBkODAyMTA4ODk5OTYxMmYz MjU5MTE3MzhhYTlhZGFlNTVjNDVmZjQuLmU1MzQ1MTI2OWY5MDRhOGZmZTQ5ZjljOWUwYmExNTNi ZDgzMTU0MTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMjEtMDItMDQgIFNpaHVpIExp dSAgPHNpaHVpX2xpdUBhcHBlLmNvbT4KKworICAgICAgICBSRUdSRVNTSU9OKHIyNzIzMzcpOiBj cmFzaCB1bmRlciBXZWJDb3JlOjpTcGVlY2hSZWNvZ25pemVyOjpzZXRJbmFjdGl2ZSgpCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjE0NTEKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYW4gZWFybHkg cmV0dXJuIGluIFNwZWVjaFJlY29nbml6ZXIncyBkZWxlZ2F0ZSBjYWxsYmFjay4KKworICAgICAg ICBBUEkgdGVzdDogV2ViS2l0Mi5TcGVlY2hSZWNvZ25pdGlvbldlYlByb2Nlc3NDcmFzaAorCisg ICAgICAgICogVUlQcm9jZXNzL1NwZWVjaFJlY29nbml0aW9uU2VydmVyLmNwcDoKKyAgICAgICAg KFdlYktpdDo6U3BlZWNoUmVjb2duaXRpb25TZXJ2ZXI6OmhhbmRsZVJlcXVlc3QpOgorCiAyMDIx LTAyLTA0ICBBZHJpYW4gUGVyZXogZGUgQ2FzdHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CiAKICAg ICAgICAgVW5yZXZpZXdlZC4gVXBkYXRlIE9wdGlvbnNXUEUuY21ha2UgYW5kIE5FV1MgZm9yIHRo ZSAyLjMxLjEgcmVsZWFzZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvU3Bl ZWNoUmVjb2duaXRpb25TZXJ2ZXIuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvU3BlZWNo UmVjb2duaXRpb25TZXJ2ZXIuY3BwCmluZGV4IDNiMWQwZTg4YzMwZmNjN2U0OTZlMjE0ZDY3ZjBi NWYzZDk4ZTRlZWIuLjUxYWNlNTY2NzVkOTc1MTYwZDNiMWY5Mzc2Mjg1YWYwN2FmNjlmMTIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1NwZWVjaFJlY29nbml0aW9uU2VydmVy LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9TcGVlY2hSZWNvZ25pdGlvblNlcnZl ci5jcHAKQEAgLTk0LDYgKzk0LDkgQEAgdm9pZCBTcGVlY2hSZWNvZ25pdGlvblNlcnZlcjo6aGFu ZGxlUmVxdWVzdChVbmlxdWVSZWY8V2ViQ29yZTo6U3BlZWNoUmVjb2duaXRpb24KIAogICAgICAg ICBzZW5kVXBkYXRlKHVwZGF0ZSk7CiAKKyAgICAgICAgaWYgKCFtX3JlY29nbml6ZXIgfHwgbV9y ZWNvZ25pemVyLT5jbGllbnRJZGVudGlmaWVyKCkgIT0gdXBkYXRlLmNsaWVudElkZW50aWZpZXIo KSkKKyAgICAgICAgICAgIHJldHVybjsKKwogICAgICAgICBpZiAodXBkYXRlLnR5cGUoKSA9PSBX ZWJDb3JlOjpTcGVlY2hSZWNvZ25pdGlvblVwZGF0ZVR5cGU6OkVycm9yKQogICAgICAgICAgICAg bV9yZWNvZ25pemVyLT5hYm9ydCgpOwogICAgICAgICBlbHNlIGlmICh1cGRhdGUudHlwZSgpID09 IFdlYkNvcmU6OlNwZWVjaFJlY29nbml0aW9uVXBkYXRlVHlwZTo6RW5kKQpkaWZmIC0tZ2l0IGEv VG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDVlZTY4YmMwOWQwNTMxZjRi NmQ4MjZkNjBjNzRhYjRmNDdmYzZlNWUuLmMyM2I3ODllN2ViMmJmMTlhZDU5YWI4OTI0YjBlYjY4 ODZmZDNkNjUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxNCBAQAorMjAyMS0wMi0wNCAgU2lodWkgTGl1ICA8c2lodWlfbGl1QGFw cGUuY29tPgorCisgICAgICAgIFJFR1JFU1NJT04ocjI3MjMzNyk6IGNyYXNoIHVuZGVyIFdlYkNv cmU6OlNwZWVjaFJlY29nbml6ZXI6OnNldEluYWN0aXZlKCkKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyMTQ1MQorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRD b2NvYS9TcGVlY2hSZWNvZ25pdGlvbi5tbToKKyAgICAgICAgKC1bU3BlZWNoUmVjb2duaXRpb25O YXZpZ2F0aW9uRGVsZWdhdGUgX3dlYlZpZXc6d2ViQ29udGVudFByb2Nlc3NEaWRUZXJtaW5hdGVX aXRoUmVhc29uOl0pOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisKIDIwMjEtMDIt MDQgIEFha2FzaCBKYWluICA8YWFrYXNoX2phaW5AYXBwbGUuY29tPgogCiAgICAgICAgIFtidWls ZC53ZWJraXQub3JnXSBVcGRhdGUgZGFzaGJvYXJkIGxpbmtzIGZvciBsYXlvdXQgdGVzdCByZXN1 bHRzCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1Nw ZWVjaFJlY29nbml0aW9uLm1tIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2Nv YS9TcGVlY2hSZWNvZ25pdGlvbi5tbQppbmRleCA3NDM0NThmMzA5Nzg1Njc3NzJhMGE0ZWY1YTc4 NjFiMzFiNjg0ZGU3Li4wNGIxNmQxM2Q5OGQ1MmEyY2ZiYWJjODI0NjNkZTc3ZjZiYzNmYjVmIDEw MDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1NwZWVjaFJl Y29nbml0aW9uLm1tCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2Ev U3BlZWNoUmVjb2duaXRpb24ubW0KQEAgLTMwMyw2ICszMDMsMzMgQEAgVEVTVChXZWJLaXQyLCBT cGVlY2hSZWNvZ25pdGlvbk1lZGlhQ2FwdHVyZVN0YXRlQ2hhbmdlKQogICAgIEVYUEVDVF9GQUxT RShpc0NhcHR1cmluZyk7CiB9CiAKK1RFU1QoV2ViS2l0MiwgU3BlZWNoUmVjb2duaXRpb25XZWJQ cm9jZXNzQ3Jhc2gpCit7CisgICAgYXV0byBjb25maWd1cmF0aW9uID0gYWRvcHROUyhbW1dLV2Vi Vmlld0NvbmZpZ3VyYXRpb24gYWxsb2NdIGluaXRdKTsKKyAgICBhdXRvIGhhbmRsZXIgPSBhZG9w dE5TKFtbU3BlZWNoUmVjb2duaXRpb25NZXNzYWdlSGFuZGxlciBhbGxvY10gaW5pdF0pOworICAg IFtbY29uZmlndXJhdGlvbiB1c2VyQ29udGVudENvbnRyb2xsZXJdIGFkZFNjcmlwdE1lc3NhZ2VI YW5kbGVyOmhhbmRsZXIuZ2V0KCkgbmFtZTpAInRlc3RIYW5kbGVyIl07CisgICAgYXV0byBwcmVm ZXJlbmNlcyA9IFtjb25maWd1cmF0aW9uIHByZWZlcmVuY2VzXTsKKyAgICBwcmVmZXJlbmNlcy5f bW9ja0NhcHR1cmVEZXZpY2VzRW5hYmxlZCA9IFlFUzsKKyAgICBwcmVmZXJlbmNlcy5fc3BlZWNo UmVjb2duaXRpb25FbmFibGVkID0gWUVTOworICAgIGF1dG8gZGVsZWdhdGUgPSBhZG9wdE5TKFtb U3BlZWNoUmVjb2duaXRpb25VSURlbGVnYXRlIGFsbG9jXSBpbml0XSk7CisgICAgc2hvdWxkR3Jh bnRQZXJtaXNzaW9uUmVxdWVzdCA9IHRydWU7CisgICAgCisgICAgQGF1dG9yZWxlYXNlcG9vbCB7 CisgICAgICAgIGF1dG8gd2ViVmlldyA9IGFkb3B0TlMoW1tUZXN0V0tXZWJWaWV3IGFsbG9jXSBp bml0V2l0aEZyYW1lOkNHUmVjdE1ha2UoMCwgMCwgODAwLCA2MDApIGNvbmZpZ3VyYXRpb246Y29u ZmlndXJhdGlvbi5nZXQoKV0pOworICAgICAgICBbd2ViVmlldyBzZXRVSURlbGVnYXRlOmRlbGVn YXRlLmdldCgpXTsKKworICAgICAgICByZWNlaXZlZFNjcmlwdE1lc3NhZ2UgPSBmYWxzZTsKKyAg ICAgICAgW3dlYlZpZXcgc3luY2hyb25vdXNseUxvYWRUZXN0UGFnZU5hbWVkOkAic3BlZWNocmVj b2duaXRpb24tYmFzaWMiXTsKKyAgICAgICAgW3dlYlZpZXcgZXZhbHVhdGVKYXZhU2NyaXB0OkAi c3RhcnQoKTsiIGNvbXBsZXRpb25IYW5kbGVyOm5pbF07CisgICAgICAgIFRlc3RXZWJLaXRBUEk6 OlV0aWw6OnJ1bigmcmVjZWl2ZWRTY3JpcHRNZXNzYWdlKTsKKyAgICAgICAgRVhQRUNUX1dLX1NU UkVRKEAiU3RhcnQiLCBbbGFzdFNjcmlwdE1lc3NhZ2UgYm9keV0pOworCisgICAgICAgIFt3ZWJW aWV3IF9raWxsV2ViQ29udGVudFByb2Nlc3NdOworICAgIH0KKworICAgIFRlc3RXZWJLaXRBUEk6 OlV0aWw6OnNsZWVwKDAuNSk7Cit9CisKICNlbmRpZgogCiB9IC8vIG5hbWVzcGFjZSBUZXN0V2Vi S2l0QVBJCg== 419438 2021-02-05 11:24:32 -0800 2021-02-05 16:03:29 -0800 Patch bug-221451-20210205112430.patch text/plain 7514 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjcyNDE3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTUxMmIzZDNiNDhiNmVj NjA5MDEwMjA1NWVmZjM5ZGY3MjNlZDM0YS4uYmY4N2E3YmUzYTc3ZGM4Y2ZiMjE2ZWJkMDExNzg2 YzQ1NDNiNmM2NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDIxLTAyLTA1ICBTaWh1 aSBMaXUgIDxzaWh1aV9saXVAYXBwZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjcyMzM3 KTogY3Jhc2ggdW5kZXIgV2ViQ29yZTo6U3BlZWNoUmVjb2duaXplcjo6c2V0SW5hY3RpdmUoKQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjIxNDUxCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3RvcCBzZW5k aW5nIHVwZGF0ZSBpbiBTcGVlY2hSZWNvZ25pemVyJ3MgZGVzdHJ1Y3RvciwgaW5zdGVhZCwgd2Ug c2hvdWxkIGRvbmUgc2VuZGluZyB1cGRhdGUgYmVmb3JlIGRlc3Ryb3lpbmcgCisgICAgICAgIGl0 LgorCisgICAgICAgIEFQSSB0ZXN0OiBXZWJLaXQyLlNwZWVjaFJlY29nbml0aW9uV2ViUHJvY2Vz c0NyYXNoLgorCisgICAgICAgICogTW9kdWxlcy9zcGVlY2gvU3BlZWNoUmVjb2duaXplci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpTcGVlY2hSZWNvZ25pemVyOjpwcmVwYXJlRm9yRGVzdHJ1Y3Rp b24pOgorICAgICAgICAoV2ViQ29yZTo6U3BlZWNoUmVjb2duaXplcjo6flNwZWVjaFJlY29nbml6 ZXIpOiBEZWxldGVkLgorICAgICAgICAqIE1vZHVsZXMvc3BlZWNoL1NwZWVjaFJlY29nbml6ZXIu aDoKKwogMjAyMS0wMi0wNSAgWmFsYW4gQnVqdGFzICA8emFsYW5AYXBwbGUuY29tPgogCiAgICAg ICAgIFtMRkNdW0lGQ10gQWRkIHN1cHBvcnQgZm9yICJ3b3JkIHNlcGFyYXRvciIgd2hlbiB0aGUg d2hpdGVzcGFjZSBjb250ZW50IGhhcyBtdWx0aXBsZSBjaGFyYWN0ZXJzCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDYz NjgyZjY3ZmZlMjcyNzAwNTlhZGI3YzEwMjQyMzYyZGNkMmQxNjIuLmVkYWIyNTA2NDQxYmU1Njhk ZDUzMmNmNDg2ZTExY2U5NDNhZGFhYWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMjEt MDItMDUgIFNpaHVpIExpdSAgPHNpaHVpX2xpdUBhcHBlLmNvbT4KKworICAgICAgICBSRUdSRVNT SU9OKHIyNzIzMzcpOiBjcmFzaCB1bmRlciBXZWJDb3JlOjpTcGVlY2hSZWNvZ25pemVyOjpzZXRJ bmFjdGl2ZSgpCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMjE0NTEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICAqIFVJUHJvY2Vzcy9TcGVlY2hSZWNvZ25pdGlvblNlcnZlci5jcHA6CisgICAgICAgIChXZWJL aXQ6OlNwZWVjaFJlY29nbml0aW9uU2VydmVyOjpoYW5kbGVSZXF1ZXN0KToKKwogMjAyMS0wMi0w NSAgU2lodWkgTGl1ICA8c2lodWlfbGl1QGFwcGUuY29tPgogCiAgICAgICAgIFNwZWVjaFJlY29n bml0aW9uUGVybWlzc2lvbk1hbmFnZXIgc2hvdWxkIG5vdCBoYW5kbGUgcmVxdWVzdHMgdGhhdCBh cmUgYWxyZWFkeSBjYW5jZWxsZWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv c3BlZWNoL1NwZWVjaFJlY29nbml6ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9zcGVl Y2gvU3BlZWNoUmVjb2duaXplci5jcHAKaW5kZXggMDk4MjlmOGI0YWFlZDQ2YTk2MDYxZjkwNzY3 MjU1NDQwZDgzMmFkNy4uMTE0Zjk1MmNkOTY4YzIyYjMzZTMzODY2YTAxMjVmNmM5NDBiNmEzNiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9zcGVlY2gvU3BlZWNoUmVjb2duaXpl ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9zcGVlY2gvU3BlZWNoUmVjb2duaXpl ci5jcHAKQEAgLTQyLDEyICs0Miw2IEBAIFNwZWVjaFJlY29nbml6ZXI6OlNwZWVjaFJlY29nbml6 ZXIoRGVsZWdhdGVDYWxsYmFjayYmIGRlbGVnYXRlQ2FsbGJhY2ssIFVuaXF1ZVJlCiB7CiB9CiAK LVNwZWVjaFJlY29nbml6ZXI6On5TcGVlY2hSZWNvZ25pemVyKCkKLXsKLSAgICBpZiAobV9zdGF0 ZSA9PSBTdGF0ZTo6QWJvcnRpbmcgfHwgbV9zdGF0ZSA9PSBTdGF0ZTo6U3RvcHBpbmcgfHwgbV9z dGF0ZSA9PSBTdGF0ZTo6UnVubmluZykKLSAgICAgICAgbV9kZWxlZ2F0ZUNhbGxiYWNrKFNwZWVj aFJlY29nbml0aW9uVXBkYXRlOjpjcmVhdGUoY2xpZW50SWRlbnRpZmllcigpLCBTcGVlY2hSZWNv Z25pdGlvblVwZGF0ZVR5cGU6OkVuZCkpOwotfQotCiB2b2lkIFNwZWVjaFJlY29nbml6ZXI6OmFi b3J0KE9wdGlvbmFsPFNwZWVjaFJlY29nbml0aW9uRXJyb3I+JiYgZXJyb3IpCiB7CiAgICAgaWYg KG1fc3RhdGUgPT0gU3RhdGU6OkFib3J0aW5nIHx8IG1fc3RhdGUgPT0gU3RhdGU6OkluYWN0aXZl KQpAQCAtNzYsNiArNzAsMTUgQEAgU3BlZWNoUmVjb2duaXRpb25Db25uZWN0aW9uQ2xpZW50SWRl bnRpZmllciBTcGVlY2hSZWNvZ25pemVyOjpjbGllbnRJZGVudGlmaWVyKCkKICAgICByZXR1cm4g bV9yZXF1ZXN0LT5jbGllbnRJZGVudGlmaWVyKCk7CiB9CiAKK3ZvaWQgU3BlZWNoUmVjb2duaXpl cjo6cHJlcGFyZUZvckRlc3RydWN0aW9uKCkKK3sKKyAgICBBU1NFUlQobV9zdGF0ZSA9PSBTdGF0 ZTo6QWJvcnRpbmcpOworCisgICAgYXV0byBkZWxlZ2F0ZUNhbGxiYWNrID0gc3RkOjpleGNoYW5n ZShtX2RlbGVnYXRlQ2FsbGJhY2ssIFtdKGNvbnN0IFNwZWVjaFJlY29nbml0aW9uVXBkYXRlJikg eyB9KTsKKyAgICBkZWxlZ2F0ZUNhbGxiYWNrKFNwZWVjaFJlY29nbml0aW9uVXBkYXRlOjpjcmVh dGUoY2xpZW50SWRlbnRpZmllcigpLCBTcGVlY2hSZWNvZ25pdGlvblVwZGF0ZVR5cGU6OkVuZCkp OworICAgIG1fc3RhdGUgPSBTdGF0ZTo6SW5hY3RpdmU7Cit9CisKICNpZiBFTkFCTEUoTUVESUFf U1RSRUFNKQogCiB2b2lkIFNwZWVjaFJlY29nbml6ZXI6OnN0YXJ0KFJlZjxSZWFsdGltZU1lZGlh U291cmNlPiYmIHNvdXJjZSwgYm9vbCBtb2NrU3BlZWNoUmVjb2duaXRpb25FbmFibGVkKQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9zcGVlY2gvU3BlZWNoUmVjb2duaXplci5o IGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9zcGVlY2gvU3BlZWNoUmVjb2duaXplci5oCmluZGV4 IGRjMTlmZWU5M2JjMDVmYWE2OTgyYzEzZmFiYzcxOTliZGQ1ZWQ4NmQuLjJhY2E1N2Y1Y2E0Yjgx OTQ2NjViYjZiODc2ZDY4NDhhMmNjZGE4ZWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvc3BlZWNoL1NwZWVjaFJlY29nbml6ZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1 bGVzL3NwZWVjaC9TcGVlY2hSZWNvZ25pemVyLmgKQEAgLTQ1LDcgKzQ1LDYgQEAgY2xhc3MgU3Bl ZWNoUmVjb2duaXplciA6IHB1YmxpYyBDYW5NYWtlV2Vha1B0cjxTcGVlY2hSZWNvZ25pemVyPiB7 CiBwdWJsaWM6CiAgICAgdXNpbmcgRGVsZWdhdGVDYWxsYmFjayA9IEZ1bmN0aW9uPHZvaWQoY29u c3QgU3BlZWNoUmVjb2duaXRpb25VcGRhdGUmKT47CiAgICAgV0VCQ09SRV9FWFBPUlQgZXhwbGlj aXQgU3BlZWNoUmVjb2duaXplcihEZWxlZ2F0ZUNhbGxiYWNrJiYsIFVuaXF1ZVJlZjxTcGVlY2hS ZWNvZ25pdGlvblJlcXVlc3Q+JiYpOwotICAgIFdFQkNPUkVfRVhQT1JUIH5TcGVlY2hSZWNvZ25p emVyKCk7CiAKICNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQogICAgIFdFQkNPUkVfRVhQT1JUIHZv aWQgc3RhcnQoUmVmPFJlYWx0aW1lTWVkaWFTb3VyY2U+JiYsIGJvb2wgbW9ja1NwZWVjaFJlY29n bml0aW9uRW5hYmxlZCk7CkBAIC01Nyw2ICs1Niw3IEBAIHB1YmxpYzoKICAgICBTcGVlY2hSZWNv Z25pdGlvbkNhcHR1cmVTb3VyY2UqIHNvdXJjZSgpIHsgcmV0dXJuIG1fc291cmNlLmdldCgpOyB9 CiAKICAgICB2b2lkIHNldEluYWN0aXZlKCkgeyBtX3N0YXRlID0gU3RhdGU6OkluYWN0aXZlOyB9 CisgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBwcmVwYXJlRm9yRGVzdHJ1Y3Rpb24oKTsKIAogcHJp dmF0ZToKICAgICBlbnVtIGNsYXNzIFN0YXRlIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv VUlQcm9jZXNzL1NwZWVjaFJlY29nbml0aW9uU2VydmVyLmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL1NwZWVjaFJlY29nbml0aW9uU2VydmVyLmNwcAppbmRleCAwNWVjZGY1YjgzZmJhNGE5 YWNiZDQyYzM0ODFlNjUzMjhmMzZmZTNlLi41ZDk2MmQ3M2RlNGVkMDMzNmFjYTUzNTY3MzFjNDU2 ODllYmI5ZWZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9TcGVlY2hSZWNv Z25pdGlvblNlcnZlci5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvU3BlZWNoUmVj b2duaXRpb25TZXJ2ZXIuY3BwCkBAIC04MSw4ICs4MSwxMCBAQCB2b2lkIFNwZWVjaFJlY29nbml0 aW9uU2VydmVyOjpyZXF1ZXN0UGVybWlzc2lvbkZvclJlcXVlc3QoV2ViQ29yZTo6U3BlZWNoUmVj b2duaQogCiB2b2lkIFNwZWVjaFJlY29nbml0aW9uU2VydmVyOjpoYW5kbGVSZXF1ZXN0KFVuaXF1 ZVJlZjxXZWJDb3JlOjpTcGVlY2hSZWNvZ25pdGlvblJlcXVlc3Q+JiYgcmVxdWVzdCkKIHsKLSAg ICBpZiAobV9yZWNvZ25pemVyKQorICAgIGlmIChtX3JlY29nbml6ZXIpIHsKICAgICAgICAgbV9y ZWNvZ25pemVyLT5hYm9ydChXZWJDb3JlOjpTcGVlY2hSZWNvZ25pdGlvbkVycm9yIHsgV2ViQ29y ZTo6U3BlZWNoUmVjb2duaXRpb25FcnJvclR5cGU6OkFib3J0ZWQsICJBbm90aGVyIHJlcXVlc3Qg aXMgc3RhcnRlZCJfcyB9KTsKKyAgICAgICAgbV9yZWNvZ25pemVyLT5wcmVwYXJlRm9yRGVzdHJ1 Y3Rpb24oKTsKKyAgICB9CiAKICAgICBhdXRvIGNsaWVudElkZW50aWZpZXIgPSByZXF1ZXN0LT5j bGllbnRJZGVudGlmaWVyKCk7CiAgICAgbV9yZWNvZ25pemVyID0gbWFrZVVuaXF1ZTxXZWJDb3Jl OjpTcGVlY2hSZWNvZ25pemVyPihbdGhpcywgd2Vha1RoaXMgPSBtYWtlV2Vha1B0cih0aGlzKV0o YXV0byYgdXBkYXRlKSB7CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFu Z2VMb2cKaW5kZXggMjJjMmUyZDFiYjg2ODM5ZTM5MWIyOGQ5YTk5ZWVjOGMxNjM2OThhYi4uMjgy YTBhODlmZWNjZmEzMDFlZjYwZmRkYTA2Y2QxOGQ4ZDAzY2YxNCAxMDA2NDQKLS0tIGEvVG9vbHMv Q2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisyMDIxLTAy LTA1ICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lP TihyMjcyMzM3KTogY3Jhc2ggdW5kZXIgV2ViQ29yZTo6U3BlZWNoUmVjb2duaXplcjo6c2V0SW5h Y3RpdmUoKQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjIxNDUxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg KiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1NwZWVjaFJlY29nbml0aW9uLm1tOgor ICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisKIDIwMjEtMDItMDUgIExhdXJvIE1vdXJh ICA8bG1vdXJhQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0ZsYXRwYWsgU0RLXSBQcmludCBzdGRl cnIgd2hlbiBjb3JlZHVtcGN0bCBmYWlscwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0cy9XZWJLaXRDb2NvYS9TcGVlY2hSZWNvZ25pdGlvbi5tbSBiL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvU3BlZWNoUmVjb2duaXRpb24ubW0KaW5kZXggNzQzNDU4 ZjMwOTc4NTY3NzcyYTBhNGVmNWE3ODYxYjMxYjY4NGRlNy4uODNjMzhhYTExYjQ2MzNjODczN2U5 Yjc2MzRkMTJmY2FjMGI1ZmQ4ZCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJLaXRDb2NvYS9TcGVlY2hSZWNvZ25pdGlvbi5tbQorKysgYi9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdENvY29hL1NwZWVjaFJlY29nbml0aW9uLm1tCkBAIC0zMDUsNCArMzA1 LDMxIEBAIFRFU1QoV2ViS2l0MiwgU3BlZWNoUmVjb2duaXRpb25NZWRpYUNhcHR1cmVTdGF0ZUNo YW5nZSkKIAogI2VuZGlmCiAKK1RFU1QoV2ViS2l0MiwgU3BlZWNoUmVjb2duaXRpb25XZWJQcm9j ZXNzQ3Jhc2gpCit7CisgICAgYXV0byBjb25maWd1cmF0aW9uID0gYWRvcHROUyhbW1dLV2ViVmll d0NvbmZpZ3VyYXRpb24gYWxsb2NdIGluaXRdKTsKKyAgICBhdXRvIGhhbmRsZXIgPSBhZG9wdE5T KFtbU3BlZWNoUmVjb2duaXRpb25NZXNzYWdlSGFuZGxlciBhbGxvY10gaW5pdF0pOworICAgIFtb Y29uZmlndXJhdGlvbiB1c2VyQ29udGVudENvbnRyb2xsZXJdIGFkZFNjcmlwdE1lc3NhZ2VIYW5k bGVyOmhhbmRsZXIuZ2V0KCkgbmFtZTpAInRlc3RIYW5kbGVyIl07CisgICAgYXV0byBwcmVmZXJl bmNlcyA9IFtjb25maWd1cmF0aW9uIHByZWZlcmVuY2VzXTsKKyAgICBwcmVmZXJlbmNlcy5fbW9j a0NhcHR1cmVEZXZpY2VzRW5hYmxlZCA9IFlFUzsKKyAgICBwcmVmZXJlbmNlcy5fc3BlZWNoUmVj b2duaXRpb25FbmFibGVkID0gWUVTOworICAgIGF1dG8gZGVsZWdhdGUgPSBhZG9wdE5TKFtbU3Bl ZWNoUmVjb2duaXRpb25VSURlbGVnYXRlIGFsbG9jXSBpbml0XSk7CisgICAgc2hvdWxkR3JhbnRQ ZXJtaXNzaW9uUmVxdWVzdCA9IHRydWU7CisKKyAgICBAYXV0b3JlbGVhc2Vwb29sIHsKKyAgICAg ICAgYXV0byB3ZWJWaWV3ID0gYWRvcHROUyhbW1Rlc3RXS1dlYlZpZXcgYWxsb2NdIGluaXRXaXRo RnJhbWU6Q0dSZWN0TWFrZSgwLCAwLCA4MDAsIDYwMCkgY29uZmlndXJhdGlvbjpjb25maWd1cmF0 aW9uLmdldCgpXSk7CisgICAgICAgIFt3ZWJWaWV3IHNldFVJRGVsZWdhdGU6ZGVsZWdhdGUuZ2V0 KCldOworCisgICAgICAgIHJlY2VpdmVkU2NyaXB0TWVzc2FnZSA9IGZhbHNlOworICAgICAgICBb d2ViVmlldyBzeW5jaHJvbm91c2x5TG9hZFRlc3RQYWdlTmFtZWQ6QCJzcGVlY2hyZWNvZ25pdGlv bi1iYXNpYyJdOworICAgICAgICBbd2ViVmlldyBldmFsdWF0ZUphdmFTY3JpcHQ6QCJzdGFydCgp OyIgY29tcGxldGlvbkhhbmRsZXI6bmlsXTsKKyAgICAgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6 cnVuKCZyZWNlaXZlZFNjcmlwdE1lc3NhZ2UpOworICAgICAgICBFWFBFQ1RfV0tfU1RSRVEoQCJT dGFydCIsIFtsYXN0U2NyaXB0TWVzc2FnZSBib2R5XSk7CisKKyAgICAgICAgW3dlYlZpZXcgX2tp bGxXZWJDb250ZW50UHJvY2Vzc107CisgICAgfQorCisgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6 c2xlZXAoMC41KTsKK30KKwogfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSQo= 419477 2021-02-05 16:03:31 -0800 2021-02-05 16:43:26 -0800 Patch for landing bug-221451-20210205160330.patch text/plain 7680 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjcyNDE3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTUxMmIzZDNiNDhiNmVj NjA5MDEwMjA1NWVmZjM5ZGY3MjNlZDM0YS4uNTY2MWUzODYzZWYyYzhhZTEyZjE4ZTU4YTIzNTA2 MGNkNDRiNGYyNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDIxLTAyLTA1ICBTaWh1 aSBMaXUgIDxzaWh1aV9saXVAYXBwZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjcyMzM3 KTogY3Jhc2ggdW5kZXIgV2ViQ29yZTo6U3BlZWNoUmVjb2duaXplcjo6c2V0SW5hY3RpdmUoKQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjIxNDUxCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgWW91ZW5uIEZhYmxldC4KKworICAgICAgICBTdG9wIHNlbmRp bmcgZmluYWwgdXBkYXRlIGluIFNwZWVjaFJlY29nbml6ZXIncyBkZXN0cnVjdG9yIGFuZCBzZW5k IGl0IGluIHByZXBhcmVGb3JEZXN0cnVjdGlvbigpIGluc3RlYWQsIHNvIAorICAgICAgICB0aGF0 IG5vIHVwZGF0ZSB3aWxsIGJlIHNlbnQgZm9yIGEgZGVzdHJveWVkIFNwZWVjaFJlY29nbml6ZXIu CisKKyAgICAgICAgQVBJIHRlc3Q6IFdlYktpdDIuU3BlZWNoUmVjb2duaXRpb25XZWJQcm9jZXNz Q3Jhc2guCisKKyAgICAgICAgKiBNb2R1bGVzL3NwZWVjaC9TcGVlY2hSZWNvZ25pemVyLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlNwZWVjaFJlY29nbml6ZXI6OnByZXBhcmVGb3JEZXN0cnVjdGlv bik6CisgICAgICAgIChXZWJDb3JlOjpTcGVlY2hSZWNvZ25pemVyOjp+U3BlZWNoUmVjb2duaXpl cik6IERlbGV0ZWQuCisgICAgICAgICogTW9kdWxlcy9zcGVlY2gvU3BlZWNoUmVjb2duaXplci5o OgorCiAyMDIxLTAyLTA1ICBaYWxhbiBCdWp0YXMgIDx6YWxhbkBhcHBsZS5jb20+CiAKICAgICAg ICAgW0xGQ11bSUZDXSBBZGQgc3VwcG9ydCBmb3IgIndvcmQgc2VwYXJhdG9yIiB3aGVuIHRoZSB3 aGl0ZXNwYWNlIGNvbnRlbnQgaGFzIG11bHRpcGxlIGNoYXJhY3RlcnMKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggNjM2 ODJmNjdmZmUyNzI3MDA1OWFkYjdjMTAyNDIzNjJkY2QyZDE2Mi4uNDhmM2Y0NjQyZDI2ZWZhNjg4 ZmMxOWRlZjNiZTg2ZDQ5ODdhZjJjMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAyMS0w Mi0wNSAgU2lodWkgTGl1ICA8c2lodWlfbGl1QGFwcGUuY29tPgorCisgICAgICAgIFJFR1JFU1NJ T04ocjI3MjMzNyk6IGNyYXNoIHVuZGVyIFdlYkNvcmU6OlNwZWVjaFJlY29nbml6ZXI6OnNldElu YWN0aXZlKCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTIyMTQ1MQorCisgICAgICAgIFJldmlld2VkIGJ5IFlvdWVubiBGYWJsZXQuCisKKyAgICAgICAg KiBVSVByb2Nlc3MvU3BlZWNoUmVjb2duaXRpb25TZXJ2ZXIuY3BwOgorICAgICAgICAoV2ViS2l0 OjpTcGVlY2hSZWNvZ25pdGlvblNlcnZlcjo6aGFuZGxlUmVxdWVzdCk6CisKIDIwMjEtMDItMDUg IFNpaHVpIExpdSAgPHNpaHVpX2xpdUBhcHBlLmNvbT4KIAogICAgICAgICBTcGVlY2hSZWNvZ25p dGlvblBlcm1pc3Npb25NYW5hZ2VyIHNob3VsZCBub3QgaGFuZGxlIHJlcXVlc3RzIHRoYXQgYXJl IGFscmVhZHkgY2FuY2VsbGVkCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Nw ZWVjaC9TcGVlY2hSZWNvZ25pemVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvc3BlZWNo L1NwZWVjaFJlY29nbml6ZXIuY3BwCmluZGV4IDA5ODI5ZjhiNGFhZWQ0NmE5NjA2MWY5MDc2NzI1 NTQ0MGQ4MzJhZDcuLjZmMTVmYmVkMTE0ODNjYmEzNzIyN2NmMTg2YWVlN2Y5ZmM3NDMzNTMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvc3BlZWNoL1NwZWVjaFJlY29nbml6ZXIu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvc3BlZWNoL1NwZWVjaFJlY29nbml6ZXIu Y3BwCkBAIC00MiwxMiArNDIsNiBAQCBTcGVlY2hSZWNvZ25pemVyOjpTcGVlY2hSZWNvZ25pemVy KERlbGVnYXRlQ2FsbGJhY2smJiBkZWxlZ2F0ZUNhbGxiYWNrLCBVbmlxdWVSZQogewogfQogCi1T cGVlY2hSZWNvZ25pemVyOjp+U3BlZWNoUmVjb2duaXplcigpCi17Ci0gICAgaWYgKG1fc3RhdGUg PT0gU3RhdGU6OkFib3J0aW5nIHx8IG1fc3RhdGUgPT0gU3RhdGU6OlN0b3BwaW5nIHx8IG1fc3Rh dGUgPT0gU3RhdGU6OlJ1bm5pbmcpCi0gICAgICAgIG1fZGVsZWdhdGVDYWxsYmFjayhTcGVlY2hS ZWNvZ25pdGlvblVwZGF0ZTo6Y3JlYXRlKGNsaWVudElkZW50aWZpZXIoKSwgU3BlZWNoUmVjb2du aXRpb25VcGRhdGVUeXBlOjpFbmQpKTsKLX0KLQogdm9pZCBTcGVlY2hSZWNvZ25pemVyOjphYm9y dChPcHRpb25hbDxTcGVlY2hSZWNvZ25pdGlvbkVycm9yPiYmIGVycm9yKQogewogICAgIGlmICht X3N0YXRlID09IFN0YXRlOjpBYm9ydGluZyB8fCBtX3N0YXRlID09IFN0YXRlOjpJbmFjdGl2ZSkK QEAgLTc2LDYgKzcwLDE2IEBAIFNwZWVjaFJlY29nbml0aW9uQ29ubmVjdGlvbkNsaWVudElkZW50 aWZpZXIgU3BlZWNoUmVjb2duaXplcjo6Y2xpZW50SWRlbnRpZmllcigpCiAgICAgcmV0dXJuIG1f cmVxdWVzdC0+Y2xpZW50SWRlbnRpZmllcigpOwogfQogCit2b2lkIFNwZWVjaFJlY29nbml6ZXI6 OnByZXBhcmVGb3JEZXN0cnVjdGlvbigpCit7CisgICAgaWYgKG1fc3RhdGUgPT0gU3RhdGU6Oklu YWN0aXZlKQorICAgICAgICByZXR1cm47CisKKyAgICBhdXRvIGRlbGVnYXRlQ2FsbGJhY2sgPSBz dGQ6OmV4Y2hhbmdlKG1fZGVsZWdhdGVDYWxsYmFjaywgW10oY29uc3QgU3BlZWNoUmVjb2duaXRp b25VcGRhdGUmKSB7IH0pOworICAgIGRlbGVnYXRlQ2FsbGJhY2soU3BlZWNoUmVjb2duaXRpb25V cGRhdGU6OmNyZWF0ZShjbGllbnRJZGVudGlmaWVyKCksIFNwZWVjaFJlY29nbml0aW9uVXBkYXRl VHlwZTo6RW5kKSk7CisgICAgbV9zdGF0ZSA9IFN0YXRlOjpJbmFjdGl2ZTsKK30KKwogI2lmIEVO QUJMRShNRURJQV9TVFJFQU0pCiAKIHZvaWQgU3BlZWNoUmVjb2duaXplcjo6c3RhcnQoUmVmPFJl YWx0aW1lTWVkaWFTb3VyY2U+JiYgc291cmNlLCBib29sIG1vY2tTcGVlY2hSZWNvZ25pdGlvbkVu YWJsZWQpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3NwZWVjaC9TcGVlY2hS ZWNvZ25pemVyLmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3NwZWVjaC9TcGVlY2hSZWNvZ25p emVyLmgKaW5kZXggZGMxOWZlZTkzYmMwNWZhYTY5ODJjMTNmYWJjNzE5OWJkZDVlZDg2ZC4uYmRj NGI5YWYyYzVhZmZmMGMzZDY4Njc2NDk4YjVkN2I5Nzc0ZTlkMiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy9zcGVlY2gvU3BlZWNoUmVjb2duaXplci5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvc3BlZWNoL1NwZWVjaFJlY29nbml6ZXIuaApAQCAtNDUsMTMgKzQ1LDEz IEBAIGNsYXNzIFNwZWVjaFJlY29nbml6ZXIgOiBwdWJsaWMgQ2FuTWFrZVdlYWtQdHI8U3BlZWNo UmVjb2duaXplcj4gewogcHVibGljOgogICAgIHVzaW5nIERlbGVnYXRlQ2FsbGJhY2sgPSBGdW5j dGlvbjx2b2lkKGNvbnN0IFNwZWVjaFJlY29nbml0aW9uVXBkYXRlJik+OwogICAgIFdFQkNPUkVf RVhQT1JUIGV4cGxpY2l0IFNwZWVjaFJlY29nbml6ZXIoRGVsZWdhdGVDYWxsYmFjayYmLCBVbmlx dWVSZWY8U3BlZWNoUmVjb2duaXRpb25SZXF1ZXN0PiYmKTsKLSAgICBXRUJDT1JFX0VYUE9SVCB+ U3BlZWNoUmVjb2duaXplcigpOwogCiAjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKICAgICBXRUJD T1JFX0VYUE9SVCB2b2lkIHN0YXJ0KFJlZjxSZWFsdGltZU1lZGlhU291cmNlPiYmLCBib29sIG1v Y2tTcGVlY2hSZWNvZ25pdGlvbkVuYWJsZWQpOwogI2VuZGlmCiAgICAgV0VCQ09SRV9FWFBPUlQg dm9pZCBhYm9ydChPcHRpb25hbDxTcGVlY2hSZWNvZ25pdGlvbkVycm9yPiYmID0gV1RGOjpudWxs b3B0KTsKICAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIHN0b3AoKTsKKyAgICBXRUJDT1JFX0VYUE9S VCB2b2lkIHByZXBhcmVGb3JEZXN0cnVjdGlvbigpOwogCiAgICAgV0VCQ09SRV9FWFBPUlQgU3Bl ZWNoUmVjb2duaXRpb25Db25uZWN0aW9uQ2xpZW50SWRlbnRpZmllciBjbGllbnRJZGVudGlmaWVy KCkgY29uc3Q7CiAgICAgU3BlZWNoUmVjb2duaXRpb25DYXB0dXJlU291cmNlKiBzb3VyY2UoKSB7 IHJldHVybiBtX3NvdXJjZS5nZXQoKTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvU3BlZWNoUmVjb2duaXRpb25TZXJ2ZXIuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvU3BlZWNoUmVjb2duaXRpb25TZXJ2ZXIuY3BwCmluZGV4IDA1ZWNkZjViODNmYmE0YTlhY2Jk NDJjMzQ4MWU2NTMyOGYzNmZlM2UuLjVkOTYyZDczZGU0ZWQwMzM2YWNhNTM1NjczMWM0NTY4OWVi YjllZmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1NwZWVjaFJlY29nbml0 aW9uU2VydmVyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9TcGVlY2hSZWNvZ25p dGlvblNlcnZlci5jcHAKQEAgLTgxLDggKzgxLDEwIEBAIHZvaWQgU3BlZWNoUmVjb2duaXRpb25T ZXJ2ZXI6OnJlcXVlc3RQZXJtaXNzaW9uRm9yUmVxdWVzdChXZWJDb3JlOjpTcGVlY2hSZWNvZ25p CiAKIHZvaWQgU3BlZWNoUmVjb2duaXRpb25TZXJ2ZXI6OmhhbmRsZVJlcXVlc3QoVW5pcXVlUmVm PFdlYkNvcmU6OlNwZWVjaFJlY29nbml0aW9uUmVxdWVzdD4mJiByZXF1ZXN0KQogewotICAgIGlm IChtX3JlY29nbml6ZXIpCisgICAgaWYgKG1fcmVjb2duaXplcikgewogICAgICAgICBtX3JlY29n bml6ZXItPmFib3J0KFdlYkNvcmU6OlNwZWVjaFJlY29nbml0aW9uRXJyb3IgeyBXZWJDb3JlOjpT cGVlY2hSZWNvZ25pdGlvbkVycm9yVHlwZTo6QWJvcnRlZCwgIkFub3RoZXIgcmVxdWVzdCBpcyBz dGFydGVkIl9zIH0pOworICAgICAgICBtX3JlY29nbml6ZXItPnByZXBhcmVGb3JEZXN0cnVjdGlv bigpOworICAgIH0KIAogICAgIGF1dG8gY2xpZW50SWRlbnRpZmllciA9IHJlcXVlc3QtPmNsaWVu dElkZW50aWZpZXIoKTsKICAgICBtX3JlY29nbml6ZXIgPSBtYWtlVW5pcXVlPFdlYkNvcmU6OlNw ZWVjaFJlY29nbml6ZXI+KFt0aGlzLCB3ZWFrVGhpcyA9IG1ha2VXZWFrUHRyKHRoaXMpXShhdXRv JiB1cGRhdGUpIHsKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxv ZwppbmRleCAyMmMyZTJkMWJiODY4MzllMzkxYjI4ZDlhOTllZWM4YzE2MzY5OGFiLi5iOTFlYzNm ODk2Y2YwOWY1MjMxZjUxMTc3NTg5MjNlZmNiNGNjZGM3IDEwMDY0NAotLS0gYS9Ub29scy9DaGFu Z2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMjEtMDItMDUg IFNpaHVpIExpdSAgPHNpaHVpX2xpdUBhcHBlLmNvbT4KKworICAgICAgICBSRUdSRVNTSU9OKHIy NzIzMzcpOiBjcmFzaCB1bmRlciBXZWJDb3JlOjpTcGVlY2hSZWNvZ25pemVyOjpzZXRJbmFjdGl2 ZSgpCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjE0 NTEKKworICAgICAgICBSZXZpZXdlZCBieSBZb3Vlbm4gRmFibGV0LgorCisgICAgICAgICogVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9TcGVlY2hSZWNvZ25pdGlvbi5tbToKKyAgICAg ICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDIxLTAyLTA1ICBMYXVybyBNb3VyYSAgPGxt b3VyYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtGbGF0cGFrIFNES10gUHJpbnQgc3RkZXJyIHdo ZW4gY29yZWR1bXBjdGwgZmFpbHMKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Q29jb2EvU3BlZWNoUmVjb2duaXRpb24ubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdENvY29hL1NwZWVjaFJlY29nbml0aW9uLm1tCmluZGV4IDc0MzQ1OGYzMDk3 ODU2Nzc3MmEwYTRlZjVhNzg2MWIzMWI2ODRkZTcuLjgzYzM4YWExMWI0NjMzYzg3MzdlOWI3NjM0 ZDEyZmNhYzBiNWZkOGQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2Vi S2l0Q29jb2EvU3BlZWNoUmVjb2duaXRpb24ubW0KKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXRDb2NvYS9TcGVlY2hSZWNvZ25pdGlvbi5tbQpAQCAtMzA1LDQgKzMwNSwzMSBA QCBURVNUKFdlYktpdDIsIFNwZWVjaFJlY29nbml0aW9uTWVkaWFDYXB0dXJlU3RhdGVDaGFuZ2Up CiAKICNlbmRpZgogCitURVNUKFdlYktpdDIsIFNwZWVjaFJlY29nbml0aW9uV2ViUHJvY2Vzc0Ny YXNoKQoreworICAgIGF1dG8gY29uZmlndXJhdGlvbiA9IGFkb3B0TlMoW1tXS1dlYlZpZXdDb25m aWd1cmF0aW9uIGFsbG9jXSBpbml0XSk7CisgICAgYXV0byBoYW5kbGVyID0gYWRvcHROUyhbW1Nw ZWVjaFJlY29nbml0aW9uTWVzc2FnZUhhbmRsZXIgYWxsb2NdIGluaXRdKTsKKyAgICBbW2NvbmZp Z3VyYXRpb24gdXNlckNvbnRlbnRDb250cm9sbGVyXSBhZGRTY3JpcHRNZXNzYWdlSGFuZGxlcjpo YW5kbGVyLmdldCgpIG5hbWU6QCJ0ZXN0SGFuZGxlciJdOworICAgIGF1dG8gcHJlZmVyZW5jZXMg PSBbY29uZmlndXJhdGlvbiBwcmVmZXJlbmNlc107CisgICAgcHJlZmVyZW5jZXMuX21vY2tDYXB0 dXJlRGV2aWNlc0VuYWJsZWQgPSBZRVM7CisgICAgcHJlZmVyZW5jZXMuX3NwZWVjaFJlY29nbml0 aW9uRW5hYmxlZCA9IFlFUzsKKyAgICBhdXRvIGRlbGVnYXRlID0gYWRvcHROUyhbW1NwZWVjaFJl Y29nbml0aW9uVUlEZWxlZ2F0ZSBhbGxvY10gaW5pdF0pOworICAgIHNob3VsZEdyYW50UGVybWlz c2lvblJlcXVlc3QgPSB0cnVlOworCisgICAgQGF1dG9yZWxlYXNlcG9vbCB7CisgICAgICAgIGF1 dG8gd2ViVmlldyA9IGFkb3B0TlMoW1tUZXN0V0tXZWJWaWV3IGFsbG9jXSBpbml0V2l0aEZyYW1l OkNHUmVjdE1ha2UoMCwgMCwgODAwLCA2MDApIGNvbmZpZ3VyYXRpb246Y29uZmlndXJhdGlvbi5n ZXQoKV0pOworICAgICAgICBbd2ViVmlldyBzZXRVSURlbGVnYXRlOmRlbGVnYXRlLmdldCgpXTsK KworICAgICAgICByZWNlaXZlZFNjcmlwdE1lc3NhZ2UgPSBmYWxzZTsKKyAgICAgICAgW3dlYlZp ZXcgc3luY2hyb25vdXNseUxvYWRUZXN0UGFnZU5hbWVkOkAic3BlZWNocmVjb2duaXRpb24tYmFz aWMiXTsKKyAgICAgICAgW3dlYlZpZXcgZXZhbHVhdGVKYXZhU2NyaXB0OkAic3RhcnQoKTsiIGNv bXBsZXRpb25IYW5kbGVyOm5pbF07CisgICAgICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigm cmVjZWl2ZWRTY3JpcHRNZXNzYWdlKTsKKyAgICAgICAgRVhQRUNUX1dLX1NUUkVRKEAiU3RhcnQi LCBbbGFzdFNjcmlwdE1lc3NhZ2UgYm9keV0pOworCisgICAgICAgIFt3ZWJWaWV3IF9raWxsV2Vi Q29udGVudFByb2Nlc3NdOworICAgIH0KKworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnNsZWVw KDAuNSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkK