173384 2017-06-14 14:22:44 -0700 WebKit falsely reports that a web process is unresponsive if you close a page shortly after stopping a load 2020-05-23 06:03:52 -0700 1 1 1 Unclassified WebKit WebKit2 WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 cdumez cdumez achristensen andersca beidson commit-queue ggaren giffypap79 mitz olivier.blin sam webkit-bug-importer oldest_to_newest 1319327 0 cdumez 2017-06-14 14:22:44 -0700 WebKit falsely reports that a web process is unresponsive if you close a page shortly after stopping a load. 1319328 1 cdumez 2017-06-14 14:22:59 -0700 <rdar://problem/32723779> 1319330 2 312920 cdumez 2017-06-14 14:36:07 -0700 Created attachment 312920 WIP Patch 1319334 3 312922 cdumez 2017-06-14 14:54:32 -0700 Created attachment 312922 Patch 1319342 4 312922 commit-queue 2017-06-14 15:49:45 -0700 Comment on attachment 312922 Patch Clearing flags on attachment: 312922 Committed r218295: <http://trac.webkit.org/changeset/218295> 1319343 5 commit-queue 2017-06-14 15:49:47 -0700 All reviewed patches have been landed. Closing bug. 1319472 6 312922 olivier.blin 2017-06-14 23:31:22 -0700 Comment on attachment 312922 Patch >Subversion Revision: 218277 >diff --git a/Source/WebKit2/ChangeLog b/Source/WebKit2/ChangeLog >index b7910c723e92c06e03b4528784ece3f1b7eede95..7ab5e2dd817a62e0ad1b90f7dee03ea269d04592 100644 >--- a/Source/WebKit2/ChangeLog >+++ b/Source/WebKit2/ChangeLog >@@ -1,3 +1,39 @@ >+2017-06-14 Chris Dumez <cdumez@apple.com> >+ >+ WebKit falsely reports that a web process is unresponsive if you close a page shortly after stopping a load >+ https://bugs.webkit.org/show_bug.cgi?id=173384 >+ <rdar://problem/32723779> >+ >+ Reviewed by NOBODY (OOPS!). >+ >+ WebKit falsely reports that a web process is unresponsive if you close a page shortly after stopping a load. >+ This is because WebPageProxy::stopLoad() starts the responsiveness timer and expects a StopResponsinessTimer >+ IPC from the WebProcess to stop the timer so we don't report the process as unresponsive. However, if >+ WebPageProxy::close() is called before the StopResponsinessTimer IPC has been received, the page will remove >+ itself from the message receiver map and we would no longer be able to receive the StopResponsinessTimer >+ IPC and stop the timer, even if the WebProcess sent it to the UIProcess. >+ >+ To address the issue, we now send the IPC Message to the WebProcessProxy instead of the WebPageProxy, so we >+ can stop the responsiveness timer, even after the WebPageProxy has been called. >+ >+ * UIProcess/WebPageProxy.cpp: >+ * UIProcess/WebPageProxy.h: >+ * UIProcess/WebPageProxy.messages.in: >+ * UIProcess/WebProcessProxy.cpp: >+ (WebKit::WebProcessProxy::stopResponsivenessTimer): >+ * UIProcess/WebProcessProxy.h: >+ * UIProcess/WebProcessProxy.messages.in: >+ * WebProcess/WebPage/WebPage.cpp: >+ (WebKit::SendStopResponsivenessTimer::~SendStopResponsivenessTimer): >+ (WebKit::WebPage::tryClose): >+ (WebKit::WebPage::loadRequest): >+ (WebKit::WebPage::loadDataImpl): >+ (WebKit::WebPage::stopLoading): >+ (WebKit::WebPage::reload): >+ (WebKit::WebPage::goForward): >+ (WebKit::WebPage::goBack): >+ (WebKit::WebPage::goToBackForwardItem): >+ > 2017-06-14 Jonathan Bedard <jbedard@apple.com> > > Configure screen scale for running layout tests on plus devices >diff --git a/Source/WebKit2/UIProcess/WebPageProxy.cpp b/Source/WebKit2/UIProcess/WebPageProxy.cpp >index e446aea68e1202d05528c2e402737429cff93d00..cf069c3d35a49d8107ecebfcc204ef3c77dcdf2c 100644 >--- a/Source/WebKit2/UIProcess/WebPageProxy.cpp >+++ b/Source/WebKit2/UIProcess/WebPageProxy.cpp >@@ -4996,11 +4996,6 @@ void WebPageProxy::didReceiveEvent(uint32_t opaqueType, bool handled) > } > } > >-void WebPageProxy::stopResponsivenessTimer() >-{ >- m_process->responsivenessTimer().stop(); >-} >- > void WebPageProxy::voidCallback(uint64_t callbackID) > { > auto callback = m_callbacks.take<VoidCallback>(callbackID); >diff --git a/Source/WebKit2/UIProcess/WebPageProxy.h b/Source/WebKit2/UIProcess/WebPageProxy.h >index 6a45774baf68ed31420931715d050596cd170ea5..e2246413cf8f4151558c0bbf3ecaca5e235de701 100644 >--- a/Source/WebKit2/UIProcess/WebPageProxy.h >+++ b/Source/WebKit2/UIProcess/WebPageProxy.h >@@ -1440,7 +1440,6 @@ private: > void setCursorHiddenUntilMouseMoves(bool); > > void didReceiveEvent(uint32_t opaqueType, bool handled); >- void stopResponsivenessTimer(); > > void voidCallback(uint64_t); > void dataCallback(const IPC::DataReference&, uint64_t); >diff --git a/Source/WebKit2/UIProcess/WebPageProxy.messages.in b/Source/WebKit2/UIProcess/WebPageProxy.messages.in >index 60eaa52382b96ec456de3d95d4ddb73c8c0ac56d..2c9cac43be43b14955c65a03d290d937285035b3 100644 >--- a/Source/WebKit2/UIProcess/WebPageProxy.messages.in >+++ b/Source/WebKit2/UIProcess/WebPageProxy.messages.in >@@ -39,7 +39,6 @@ messages -> WebPageProxy { > #endif // ENABLE(WEBGL) > DidChangeViewportProperties(struct WebCore::ViewportAttributes attributes) > DidReceiveEvent(uint32_t type, bool handled) >- StopResponsivenessTimer() > #if !PLATFORM(IOS) > SetCursor(WebCore::Cursor cursor) > SetCursorHiddenUntilMouseMoves(bool hiddenUntilMouseMoves) >diff --git a/Source/WebKit2/UIProcess/WebProcessProxy.cpp b/Source/WebKit2/UIProcess/WebProcessProxy.cpp >index f93331bad8fbd515582ff18695ea8c49654f69e4..4019f2730888e21effa82f7c2fc0b070588bd77d 100644 >--- a/Source/WebKit2/UIProcess/WebProcessProxy.cpp >+++ b/Source/WebKit2/UIProcess/WebProcessProxy.cpp >@@ -939,6 +939,11 @@ void WebProcessProxy::requestTermination(ProcessTerminationReason reason) > pages[i]->processDidTerminate(reason); > } > >+void WebProcessProxy::stopResponsivenessTimer() >+{ >+ responsivenessTimer().stop(); >+} >+ > void WebProcessProxy::enableSuddenTermination() > { > if (state() != State::Running) >diff --git a/Source/WebKit2/UIProcess/WebProcessProxy.h b/Source/WebKit2/UIProcess/WebProcessProxy.h >index fd9d6f3ea7f353a7b22d92025f4cd1bba3e58b75..d00b47494997439c2e8de345135c91a2531a921e 100644 >--- a/Source/WebKit2/UIProcess/WebProcessProxy.h >+++ b/Source/WebKit2/UIProcess/WebProcessProxy.h >@@ -151,6 +151,8 @@ public: > > void requestTermination(ProcessTerminationReason); > >+ void stopResponsivenessTimer(); >+ > RefPtr<API::Object> transformHandlesToObjects(API::Object*); > static RefPtr<API::Object> transformObjectsToHandles(API::Object*); > >diff --git a/Source/WebKit2/UIProcess/WebProcessProxy.messages.in b/Source/WebKit2/UIProcess/WebProcessProxy.messages.in >index 9337830c2715b489a582164d3fb56692e0ab500a..b2bb78120f55e645a6e2129ddd3f535dded485b3 100644 >--- a/Source/WebKit2/UIProcess/WebProcessProxy.messages.in >+++ b/Source/WebKit2/UIProcess/WebProcessProxy.messages.in >@@ -49,6 +49,8 @@ messages -> WebProcessProxy LegacyReceiver { > DidExceedInactiveMemoryLimit() > DidExceedCPULimit() > >+ StopResponsivenessTimer() >+ > RetainIconForPageURL(String pageURL) > ReleaseIconForPageURL(String pageURL) > >diff --git a/Source/WebKit2/WebProcess/WebPage/WebPage.cpp b/Source/WebKit2/WebProcess/WebPage/WebPage.cpp >index f52da8e1f3f95997f512bfe7860a542a80806848..2eb675db1e9c9a0f52da70cc23e2cefcb24cfa75 100644 >--- a/Source/WebKit2/WebProcess/WebPage/WebPage.cpp >+++ b/Source/WebKit2/WebProcess/WebPage/WebPage.cpp >@@ -264,18 +264,10 @@ static const Seconds maximumLayerVolatilityTimerInterval { 2_s }; > > class SendStopResponsivenessTimer { > public: >- SendStopResponsivenessTimer(WebPage* page) >- : m_page(page) >- { >- } >- > ~SendStopResponsivenessTimer() > { >- m_page->send(Messages::WebPageProxy::StopResponsivenessTimer()); >+ WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::StopResponsivenessTimer(), 0); > } >- >-private: >- WebPage* m_page; > }; > > class DeferredPageDestructor { >@@ -1180,10 +1172,10 @@ void WebPage::close() > > void WebPage::tryClose() > { >- SendStopResponsivenessTimer stopper(this); >+ SendStopResponsivenessTimer stopper; > > if (!corePage()->userInputBridge().tryClosePage()) { >- send(Messages::WebPageProxy::StopResponsivenessTimer()); >+ WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::StopResponsivenessTimer(), 0); Isn't this call duplicate? There is already a SendStopResponsivenessTimer object in the method scope, that will send the same message when destroyed. > return; > } > >@@ -1212,7 +1204,7 @@ void WebPage::platformDidReceiveLoadParameters(const LoadParameters& loadParamet > > void WebPage::loadRequest(const LoadParameters& loadParameters) > { >- SendStopResponsivenessTimer stopper(this); >+ SendStopResponsivenessTimer stopper; > > m_pendingNavigationID = loadParameters.navigationID; > >@@ -1236,7 +1228,7 @@ void WebPage::loadRequest(const LoadParameters& loadParameters) > > void WebPage::loadDataImpl(uint64_t navigationID, Ref<SharedBuffer>&& sharedBuffer, const String& MIMEType, const String& encodingName, const URL& baseURL, const URL& unreachableURL, const UserData& userData) > { >- SendStopResponsivenessTimer stopper(this); >+ SendStopResponsivenessTimer stopper; > > m_pendingNavigationID = navigationID; > >@@ -1320,7 +1312,7 @@ void WebPage::stopLoadingFrame(uint64_t frameID) > > void WebPage::stopLoading() > { >- SendStopResponsivenessTimer stopper(this); >+ SendStopResponsivenessTimer stopper; > > corePage()->userInputBridge().stopLoadingFrame(m_mainFrame->coreFrame()); > } >@@ -1337,7 +1329,7 @@ void WebPage::setDefersLoading(bool defersLoading) > > void WebPage::reload(uint64_t navigationID, uint32_t reloadOptions, const SandboxExtension::Handle& sandboxExtensionHandle) > { >- SendStopResponsivenessTimer stopper(this); >+ SendStopResponsivenessTimer stopper; > > ASSERT(!m_mainFrame->coreFrame()->loader().frameHasLoaded() || !m_pendingNavigationID); > m_pendingNavigationID = navigationID; >@@ -1348,7 +1340,7 @@ void WebPage::reload(uint64_t navigationID, uint32_t reloadOptions, const Sandbo > > void WebPage::goForward(uint64_t navigationID, uint64_t backForwardItemID) > { >- SendStopResponsivenessTimer stopper(this); >+ SendStopResponsivenessTimer stopper; > > HistoryItem* item = WebBackForwardListProxy::itemForID(backForwardItemID); > ASSERT(item); >@@ -1363,7 +1355,7 @@ void WebPage::goForward(uint64_t navigationID, uint64_t backForwardItemID) > > void WebPage::goBack(uint64_t navigationID, uint64_t backForwardItemID) > { >- SendStopResponsivenessTimer stopper(this); >+ SendStopResponsivenessTimer stopper; > > HistoryItem* item = WebBackForwardListProxy::itemForID(backForwardItemID); > ASSERT(item); >@@ -1378,7 +1370,7 @@ void WebPage::goBack(uint64_t navigationID, uint64_t backForwardItemID) > > void WebPage::goToBackForwardItem(uint64_t navigationID, uint64_t backForwardItemID) > { >- SendStopResponsivenessTimer stopper(this); >+ SendStopResponsivenessTimer stopper; > > HistoryItem* item = WebBackForwardListProxy::itemForID(backForwardItemID); > ASSERT(item); >diff --git a/Tools/ChangeLog b/Tools/ChangeLog >index ecfa4ee447ea46ae2bbb53fdf350a3b97b2528c4..ada5afbca58c9b9b1fb78f3f4c6e413913ac17ff 100644 >--- a/Tools/ChangeLog >+++ b/Tools/ChangeLog >@@ -1,3 +1,20 @@ >+2017-06-14 Chris Dumez <cdumez@apple.com> >+ >+ WebKit falsely reports that a web process is unresponsive if you close a page shortly after stopping a load >+ https://bugs.webkit.org/show_bug.cgi?id=173384 >+ <rdar://problem/32723779> >+ >+ Reviewed by NOBODY (OOPS!). >+ >+ * TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj: >+ * TestWebKitAPI/Tests/WebKit2/ResponsivenessTimer.cpp: Added. >+ Add API test coverage. >+ >+ * TestWebKitAPI/cocoa/UtilitiesCocoa.mm: >+ (TestWebKitAPI::Util::sleep): >+ Update implementation of Util::sleep() so that we actually run the run loop. >+ Otherwise, we don't process events while sleeping. >+ > 2017-06-14 Tim Horton <timothy_horton@apple.com> > > WKContentViewEditingActions API test always fails >diff --git a/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj b/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj >index 99c0c09247d03aceee633b6961036a4084d42e49..95f961c089fb5ee905528388ba6e4980c4354395 100644 >--- a/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj >+++ b/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj >@@ -483,6 +483,7 @@ > 8361F1781E610B4E00759B25 /* link-with-download-attribute-with-slashes.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 8361F1771E610B2100759B25 /* link-with-download-attribute-with-slashes.html */; }; > 837A35F11D9A1E7D00663C57 /* DownloadRequestBlobURL.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 837A35F01D9A1E6400663C57 /* DownloadRequestBlobURL.html */; }; > 83B6DE6F1EE75221001E792F /* RestoreSessionState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 83B6DE6E1EE7520F001E792F /* RestoreSessionState.cpp */; }; >+ 83DE134D1EF1C50800C1B355 /* ResponsivenessTimer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 83DE134C1EF1C4FE00C1B355 /* ResponsivenessTimer.cpp */; }; > 8E4A85371E1D1AB200F53B0F /* GridPosition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8E4A85361E1D1AA100F53B0F /* GridPosition.cpp */; }; > 930AD402150698D00067970F /* lots-of-text.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 930AD401150698B30067970F /* lots-of-text.html */; }; > 9329AA291DE3F81E003ABD07 /* TextBreakIterator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9329AA281DE3F81E003ABD07 /* TextBreakIterator.cpp */; }; >@@ -1291,6 +1292,7 @@ > 837A35F01D9A1E6400663C57 /* DownloadRequestBlobURL.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = DownloadRequestBlobURL.html; sourceTree = "<group>"; }; > 83B6DE6E1EE7520F001E792F /* RestoreSessionState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RestoreSessionState.cpp; sourceTree = "<group>"; }; > 83B88A331C80056D00BB2418 /* HTMLParserIdioms.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HTMLParserIdioms.cpp; sourceTree = "<group>"; }; >+ 83DE134C1EF1C4FE00C1B355 /* ResponsivenessTimer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ResponsivenessTimer.cpp; sourceTree = "<group>"; }; > 86BD19971A2DB05B006DCF0A /* RefCounter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RefCounter.cpp; sourceTree = "<group>"; }; > 8A2C750D16CED9550024F352 /* ResizeWindowAfterCrash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ResizeWindowAfterCrash.cpp; sourceTree = "<group>"; }; > 8A3AF93A16C9ED2700D248C1 /* ReloadPageAfterCrash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ReloadPageAfterCrash.cpp; sourceTree = "<group>"; }; >@@ -2186,6 +2188,7 @@ > 8A3AF93A16C9ED2700D248C1 /* ReloadPageAfterCrash.cpp */, > 2DD7D3A9178205D00026E1E3 /* ResizeReversePaginatedWebView.cpp */, > 8A2C750D16CED9550024F352 /* ResizeWindowAfterCrash.cpp */, >+ 83DE134C1EF1C4FE00C1B355 /* ResponsivenessTimer.cpp */, > C0BD669C131D3CF700E18F2A /* ResponsivenessTimerDoesntFireEarly.cpp */, > C0BD669E131D3CFF00E18F2A /* ResponsivenessTimerDoesntFireEarly_Bundle.cpp */, > 83B6DE6E1EE7520F001E792F /* RestoreSessionState.cpp */, >@@ -2980,6 +2983,7 @@ > 7A95BDE11E9BEC5F00865498 /* InjectedBundleAppleEvent.cpp in Sources */, > 510477781D29923B009747EB /* IDBDeleteRecovery.mm in Sources */, > 5110FCFA1E01CDB8006F8D0B /* IDBIndexUpgradeToV2.mm in Sources */, >+ 83DE134D1EF1C50800C1B355 /* ResponsivenessTimer.cpp in Sources */, > 51A587861D273AA9004BA9AF /* IndexedDBDatabaseProcessKill.mm in Sources */, > 7C83E0BE1D0A651300FEBCF3 /* IndexedDBMultiProcess.mm in Sources */, > 7C83E0BF1D0A652200FEBCF3 /* IndexedDBPersistence.mm in Sources */, >diff --git a/Tools/TestWebKitAPI/Tests/WebKit2/ResponsivenessTimer.cpp b/Tools/TestWebKitAPI/Tests/WebKit2/ResponsivenessTimer.cpp >new file mode 100644 >index 0000000000000000000000000000000000000000..06f81d53f69f716a1a8f82bba4471e52f87eecd4 >--- /dev/null >+++ b/Tools/TestWebKitAPI/Tests/WebKit2/ResponsivenessTimer.cpp >@@ -0,0 +1,96 @@ >+/* >+ * Copyright (C) 2017 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#include "config.h" >+ >+#if WK_HAVE_C_SPI >+ >+#include "PlatformUtilities.h" >+#include "PlatformWebView.h" >+ >+namespace TestWebKitAPI { >+ >+static bool didFinishLoad { false }; >+static bool didBecomeUnresponsive { false }; >+ >+static void didFinishLoadForFrame(WKPageRef, WKFrameRef, WKTypeRef, const void*) >+{ >+ didFinishLoad = true; >+} >+ >+static void processDidBecomeUnresponsive(WKPageRef page, const void*) >+{ >+ didBecomeUnresponsive = true; >+} >+ >+static void setPageLoaderClient(WKPageRef page) >+{ >+ WKPageLoaderClientV0 loaderClient; >+ memset(&loaderClient, 0, sizeof(loaderClient)); >+ >+ loaderClient.base.version = 0; >+ loaderClient.didFinishLoadForFrame = didFinishLoadForFrame; >+ loaderClient.processDidBecomeUnresponsive = processDidBecomeUnresponsive; >+ >+ WKPageSetPageLoaderClient(page, &loaderClient.base); >+} >+ >+TEST(WebKit2, ResponsivenessTimerShouldNotFireAfterTearDown) >+{ >+ WKRetainPtr<WKContextRef> context(AdoptWK, WKContextCreate()); >+ // The two views need to share the same WebContent process. >+ WKContextSetMaximumNumberOfProcesses(context.get(), 1); >+ >+ PlatformWebView webView1(context.get()); >+ setPageLoaderClient(webView1.page()); >+ >+ WKPageLoadURL(webView1.page(), adoptWK(Util::createURLForResource("simple", "html")).get()); >+ Util::run(&didFinishLoad); >+ >+ EXPECT_FALSE(didBecomeUnresponsive); >+ >+ PlatformWebView webView2(context.get()); >+ setPageLoaderClient(webView2.page()); >+ >+ didFinishLoad = false; >+ WKPageLoadURL(webView2.page(), adoptWK(Util::createURLForResource("simple", "html")).get()); >+ Util::run(&didFinishLoad); >+ >+ EXPECT_FALSE(didBecomeUnresponsive); >+ >+ // Call stopLoading() and close() on the first page in quick succession. >+ WKPageStopLoading(webView1.page()); >+ WKPageClose(webView1.page()); >+ >+ // We need to wait here because it takes 3 seconds for a process to be recognized as unresponsive. >+ Util::sleep(4); >+ >+ // We should not report the second page sharing the same process as unresponsive. >+ EXPECT_FALSE(didBecomeUnresponsive); >+} >+ >+} // namespace TestWebKitAPI >+ >+#endif >diff --git a/Tools/TestWebKitAPI/cocoa/UtilitiesCocoa.mm b/Tools/TestWebKitAPI/cocoa/UtilitiesCocoa.mm >index 1f7538548530f278f47f70a16226da63ffb1fde6..ba5a52f9b6fa7787787c2c13f0ddad6d88547cd8 100644 >--- a/Tools/TestWebKitAPI/cocoa/UtilitiesCocoa.mm >+++ b/Tools/TestWebKitAPI/cocoa/UtilitiesCocoa.mm >@@ -37,7 +37,7 @@ void run(bool* done) > > void sleep(double seconds) > { >- usleep(seconds * 1000000); >+ [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:seconds]]; > } > > } // namespace Util 1319473 7 312922 olivier.blin 2017-06-14 23:34:14 -0700 Comment on attachment 312922 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=312922&action=review > Source/WebKit2/WebProcess/WebPage/WebPage.cpp:270 > ~SendStopResponsivenessTimer() > { > - m_page->send(Messages::WebPageProxy::StopResponsivenessTimer()); > + WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::StopResponsivenessTimer(), 0); > } . > Source/WebKit2/WebProcess/WebPage/WebPage.cpp:1178 > void WebPage::tryClose() > { > - SendStopResponsivenessTimer stopper(this); > + SendStopResponsivenessTimer stopper; > > if (!corePage()->userInputBridge().tryClosePage()) { > - send(Messages::WebPageProxy::StopResponsivenessTimer()); > + WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::StopResponsivenessTimer(), 0); Isn't this call duplicate? There is already a SendStopResponsivenessTimer object in the method scope, that will send the same message when destroyed. (sorry for the previous comment) 1320573 8 312922 cdumez 2017-06-18 19:09:51 -0700 Comment on attachment 312922 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=312922&action=review >> Source/WebKit2/WebProcess/WebPage/WebPage.cpp:1178 >> + WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::StopResponsivenessTimer(), 0); > > Isn't this call duplicate? > There is already a SendStopResponsivenessTimer object in the method scope, that will send the same message when destroyed. > > (sorry for the previous comment) Yes, it looks like you're right. I'll drop it in a follow-up. 1320577 9 312922 cdumez 2017-06-18 19:15:00 -0700 Comment on attachment 312922 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=312922&action=review >>> Source/WebKit2/WebProcess/WebPage/WebPage.cpp:1178 >>> + WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::StopResponsivenessTimer(), 0); >> >> Isn't this call duplicate? >> There is already a SendStopResponsivenessTimer object in the method scope, that will send the same message when destroyed. >> >> (sorry for the previous comment) > > Yes, it looks like you're right. I'll drop it in a follow-up. https://bugs.webkit.org/show_bug.cgi?id=173533 312920 2017-06-14 14:36:07 -0700 2017-06-14 14:54:30 -0700 WIP Patch 173384_WebProcess_unresponsive_Mail_wip.patch text/plain 15312 cdumez ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKaW5kZXggZTQ0NmFlYTY4 ZTEuLmNmMDY5YzNkMzVhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2Vi UGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5 LmNwcApAQCAtNDk5NiwxMSArNDk5Niw2IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpkaWRSZWNlaXZl RXZlbnQodWludDMyX3Qgb3BhcXVlVHlwZSwgYm9vbCBoYW5kbGVkKQogICAgIH0KIH0KIAotdm9p ZCBXZWJQYWdlUHJveHk6OnN0b3BSZXNwb25zaXZlbmVzc1RpbWVyKCkKLXsKLSAgICBtX3Byb2Nl c3MtPnJlc3BvbnNpdmVuZXNzVGltZXIoKS5zdG9wKCk7Ci19Ci0KIHZvaWQgV2ViUGFnZVByb3h5 Ojp2b2lkQ2FsbGJhY2sodWludDY0X3QgY2FsbGJhY2tJRCkKIHsKICAgICBhdXRvIGNhbGxiYWNr ID0gbV9jYWxsYmFja3MudGFrZTxWb2lkQ2FsbGJhY2s+KGNhbGxiYWNrSUQpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCmluZGV4IDZhNDU3NzRiYWY2Li5lMjI0NjQxM2Nm OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCisr KyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaApAQCAtMTQ0MCw3ICsx NDQwLDYgQEAgcHJpdmF0ZToKICAgICB2b2lkIHNldEN1cnNvckhpZGRlblVudGlsTW91c2VNb3Zl cyhib29sKTsKIAogICAgIHZvaWQgZGlkUmVjZWl2ZUV2ZW50KHVpbnQzMl90IG9wYXF1ZVR5cGUs IGJvb2wgaGFuZGxlZCk7Ci0gICAgdm9pZCBzdG9wUmVzcG9uc2l2ZW5lc3NUaW1lcigpOwogCiAg ICAgdm9pZCB2b2lkQ2FsbGJhY2sodWludDY0X3QpOwogICAgIHZvaWQgZGF0YUNhbGxiYWNrKGNv bnN0IElQQzo6RGF0YVJlZmVyZW5jZSYsIHVpbnQ2NF90KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW4gYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5Lm1lc3NhZ2VzLmluCmluZGV4IDYwZWFhNTIzODJiLi4y YzljYWM0M2JlNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQ cm94eS5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5Lm1lc3NhZ2VzLmluCkBAIC0zOSw3ICszOSw2IEBAIG1lc3NhZ2VzIC0+IFdlYlBhZ2VQcm94 eSB7CiAjZW5kaWYgLy8gRU5BQkxFKFdFQkdMKQogICAgIERpZENoYW5nZVZpZXdwb3J0UHJvcGVy dGllcyhzdHJ1Y3QgV2ViQ29yZTo6Vmlld3BvcnRBdHRyaWJ1dGVzIGF0dHJpYnV0ZXMpCiAgICAg RGlkUmVjZWl2ZUV2ZW50KHVpbnQzMl90IHR5cGUsIGJvb2wgaGFuZGxlZCkKLSAgICBTdG9wUmVz cG9uc2l2ZW5lc3NUaW1lcigpCiAjaWYgIVBMQVRGT1JNKElPUykKICAgICBTZXRDdXJzb3IoV2Vi Q29yZTo6Q3Vyc29yIGN1cnNvcikKICAgICBTZXRDdXJzb3JIaWRkZW5VbnRpbE1vdXNlTW92ZXMo Ym9vbCBoaWRkZW5VbnRpbE1vdXNlTW92ZXMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9X ZWJQcm9jZXNzUHJveHkuY3BwCmluZGV4IGY5MzMzMWJhZDhmLi40MDE5ZjI3MzA4OCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKKysrIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKQEAgLTkzOSw2ICs5 MzksMTEgQEAgdm9pZCBXZWJQcm9jZXNzUHJveHk6OnJlcXVlc3RUZXJtaW5hdGlvbihQcm9jZXNz VGVybWluYXRpb25SZWFzb24gcmVhc29uKQogICAgICAgICBwYWdlc1tpXS0+cHJvY2Vzc0RpZFRl cm1pbmF0ZShyZWFzb24pOwogfQogCit2b2lkIFdlYlByb2Nlc3NQcm94eTo6c3RvcFJlc3BvbnNp dmVuZXNzVGltZXIoKQoreworICAgIHJlc3BvbnNpdmVuZXNzVGltZXIoKS5zdG9wKCk7Cit9CisK IHZvaWQgV2ViUHJvY2Vzc1Byb3h5OjplbmFibGVTdWRkZW5UZXJtaW5hdGlvbigpCiB7CiAgICAg aWYgKHN0YXRlKCkgIT0gU3RhdGU6OlJ1bm5pbmcpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv V2ViUHJvY2Vzc1Byb3h5LmgKaW5kZXggZmQ5ZDZmM2VhN2YuLmQwMGI0NzQ5NDk5IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmgKKysrIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oCkBAIC0xNTEsNiArMTUxLDgg QEAgcHVibGljOgogCiAgICAgdm9pZCByZXF1ZXN0VGVybWluYXRpb24oUHJvY2Vzc1Rlcm1pbmF0 aW9uUmVhc29uKTsKIAorICAgIHZvaWQgc3RvcFJlc3BvbnNpdmVuZXNzVGltZXIoKTsKKwogICAg IFJlZlB0cjxBUEk6Ok9iamVjdD4gdHJhbnNmb3JtSGFuZGxlc1RvT2JqZWN0cyhBUEk6Ok9iamVj dCopOwogICAgIHN0YXRpYyBSZWZQdHI8QVBJOjpPYmplY3Q+IHRyYW5zZm9ybU9iamVjdHNUb0hh bmRsZXMoQVBJOjpPYmplY3QqKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL1dlYlByb2Nlc3NQcm94eS5tZXNzYWdlcy5pbiBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9XZWJQcm9jZXNzUHJveHkubWVzc2FnZXMuaW4KaW5kZXggOTMzNzgzMGMyNzEuLmIyYmI3ODEy MGY1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5 Lm1lc3NhZ2VzLmluCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJv eHkubWVzc2FnZXMuaW4KQEAgLTQ5LDYgKzQ5LDggQEAgbWVzc2FnZXMgLT4gV2ViUHJvY2Vzc1By b3h5IExlZ2FjeVJlY2VpdmVyIHsKICAgICBEaWRFeGNlZWRJbmFjdGl2ZU1lbW9yeUxpbWl0KCkK ICAgICBEaWRFeGNlZWRDUFVMaW1pdCgpCiAKKyAgICBTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lcigp CisKICAgICBSZXRhaW5JY29uRm9yUGFnZVVSTChTdHJpbmcgcGFnZVVSTCkKICAgICBSZWxlYXNl SWNvbkZvclBhZ2VVUkwoU3RyaW5nIHBhZ2VVUkwpCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlBy b2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcAppbmRleCBmNTJkYThlMWYzZi4uMmViNjc1ZGIxZTkg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNw cAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5jcHAKQEAg LTI2NCwxOCArMjY0LDEwIEBAIHN0YXRpYyBjb25zdCBTZWNvbmRzIG1heGltdW1MYXllclZvbGF0 aWxpdHlUaW1lckludGVydmFsIHsgMl9zIH07CiAKIGNsYXNzIFNlbmRTdG9wUmVzcG9uc2l2ZW5l c3NUaW1lciB7CiBwdWJsaWM6Ci0gICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyKFdlYlBh Z2UqIHBhZ2UpCi0gICAgICAgIDogbV9wYWdlKHBhZ2UpCi0gICAgewotICAgIH0KLSAgICAKICAg ICB+U2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyKCkKICAgICB7Ci0gICAgICAgIG1fcGFnZS0+ c2VuZChNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lcigpKTsK KyAgICAgICAgV2ViUHJvY2Vzczo6c2luZ2xldG9uKCkucGFyZW50UHJvY2Vzc0Nvbm5lY3Rpb24o KS0+c2VuZChNZXNzYWdlczo6V2ViUHJvY2Vzc1Byb3h5OjpTdG9wUmVzcG9uc2l2ZW5lc3NUaW1l cigpLCAwKTsKICAgICB9Ci0KLXByaXZhdGU6Ci0gICAgV2ViUGFnZSogbV9wYWdlOwogfTsKIAog Y2xhc3MgRGVmZXJyZWRQYWdlRGVzdHJ1Y3RvciB7CkBAIC0xMTgwLDEwICsxMTcyLDEwIEBAIHZv aWQgV2ViUGFnZTo6Y2xvc2UoKQogCiB2b2lkIFdlYlBhZ2U6OnRyeUNsb3NlKCkKIHsKLSAgICBT ZW5kU3RvcFJlc3BvbnNpdmVuZXNzVGltZXIgc3RvcHBlcih0aGlzKTsKKyAgICBTZW5kU3RvcFJl c3BvbnNpdmVuZXNzVGltZXIgc3RvcHBlcjsKIAogICAgIGlmICghY29yZVBhZ2UoKS0+dXNlcklu cHV0QnJpZGdlKCkudHJ5Q2xvc2VQYWdlKCkpIHsKLSAgICAgICAgc2VuZChNZXNzYWdlczo6V2Vi UGFnZVByb3h5OjpTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lcigpKTsKKyAgICAgICAgV2ViUHJvY2Vz czo6c2luZ2xldG9uKCkucGFyZW50UHJvY2Vzc0Nvbm5lY3Rpb24oKS0+c2VuZChNZXNzYWdlczo6 V2ViUHJvY2Vzc1Byb3h5OjpTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lcigpLCAwKTsKICAgICAgICAg cmV0dXJuOwogICAgIH0KIApAQCAtMTIxMiw3ICsxMjA0LDcgQEAgdm9pZCBXZWJQYWdlOjpwbGF0 Zm9ybURpZFJlY2VpdmVMb2FkUGFyYW1ldGVycyhjb25zdCBMb2FkUGFyYW1ldGVycyYgbG9hZFBh cmFtZXQKIAogdm9pZCBXZWJQYWdlOjpsb2FkUmVxdWVzdChjb25zdCBMb2FkUGFyYW1ldGVycyYg bG9hZFBhcmFtZXRlcnMpCiB7Ci0gICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3Bw ZXIodGhpcyk7CisgICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3BwZXI7CiAKICAg ICBtX3BlbmRpbmdOYXZpZ2F0aW9uSUQgPSBsb2FkUGFyYW1ldGVycy5uYXZpZ2F0aW9uSUQ7CiAK QEAgLTEyMzYsNyArMTIyOCw3IEBAIHZvaWQgV2ViUGFnZTo6bG9hZFJlcXVlc3QoY29uc3QgTG9h ZFBhcmFtZXRlcnMmIGxvYWRQYXJhbWV0ZXJzKQogCiB2b2lkIFdlYlBhZ2U6OmxvYWREYXRhSW1w bCh1aW50NjRfdCBuYXZpZ2F0aW9uSUQsIFJlZjxTaGFyZWRCdWZmZXI+JiYgc2hhcmVkQnVmZmVy LCBjb25zdCBTdHJpbmcmIE1JTUVUeXBlLCBjb25zdCBTdHJpbmcmIGVuY29kaW5nTmFtZSwgY29u c3QgVVJMJiBiYXNlVVJMLCBjb25zdCBVUkwmIHVucmVhY2hhYmxlVVJMLCBjb25zdCBVc2VyRGF0 YSYgdXNlckRhdGEpCiB7Ci0gICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3BwZXIo dGhpcyk7CisgICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3BwZXI7CiAKICAgICBt X3BlbmRpbmdOYXZpZ2F0aW9uSUQgPSBuYXZpZ2F0aW9uSUQ7CiAKQEAgLTEzMjAsNyArMTMxMiw3 IEBAIHZvaWQgV2ViUGFnZTo6c3RvcExvYWRpbmdGcmFtZSh1aW50NjRfdCBmcmFtZUlEKQogCiB2 b2lkIFdlYlBhZ2U6OnN0b3BMb2FkaW5nKCkKIHsKLSAgICBTZW5kU3RvcFJlc3BvbnNpdmVuZXNz VGltZXIgc3RvcHBlcih0aGlzKTsKKyAgICBTZW5kU3RvcFJlc3BvbnNpdmVuZXNzVGltZXIgc3Rv cHBlcjsKIAogICAgIGNvcmVQYWdlKCktPnVzZXJJbnB1dEJyaWRnZSgpLnN0b3BMb2FkaW5nRnJh bWUobV9tYWluRnJhbWUtPmNvcmVGcmFtZSgpKTsKIH0KQEAgLTEzMzcsNyArMTMyOSw3IEBAIHZv aWQgV2ViUGFnZTo6c2V0RGVmZXJzTG9hZGluZyhib29sIGRlZmVyc0xvYWRpbmcpCiAKIHZvaWQg V2ViUGFnZTo6cmVsb2FkKHVpbnQ2NF90IG5hdmlnYXRpb25JRCwgdWludDMyX3QgcmVsb2FkT3B0 aW9ucywgY29uc3QgU2FuZGJveEV4dGVuc2lvbjo6SGFuZGxlJiBzYW5kYm94RXh0ZW5zaW9uSGFu ZGxlKQogewotICAgIFNlbmRTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lciBzdG9wcGVyKHRoaXMpOwor ICAgIFNlbmRTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lciBzdG9wcGVyOwogCiAgICAgQVNTRVJUKCFt X21haW5GcmFtZS0+Y29yZUZyYW1lKCktPmxvYWRlcigpLmZyYW1lSGFzTG9hZGVkKCkgfHwgIW1f cGVuZGluZ05hdmlnYXRpb25JRCk7CiAgICAgbV9wZW5kaW5nTmF2aWdhdGlvbklEID0gbmF2aWdh dGlvbklEOwpAQCAtMTM0OCw3ICsxMzQwLDcgQEAgdm9pZCBXZWJQYWdlOjpyZWxvYWQodWludDY0 X3QgbmF2aWdhdGlvbklELCB1aW50MzJfdCByZWxvYWRPcHRpb25zLCBjb25zdCBTYW5kYm8KIAog dm9pZCBXZWJQYWdlOjpnb0ZvcndhcmQodWludDY0X3QgbmF2aWdhdGlvbklELCB1aW50NjRfdCBi YWNrRm9yd2FyZEl0ZW1JRCkKIHsKLSAgICBTZW5kU3RvcFJlc3BvbnNpdmVuZXNzVGltZXIgc3Rv cHBlcih0aGlzKTsKKyAgICBTZW5kU3RvcFJlc3BvbnNpdmVuZXNzVGltZXIgc3RvcHBlcjsKIAog ICAgIEhpc3RvcnlJdGVtKiBpdGVtID0gV2ViQmFja0ZvcndhcmRMaXN0UHJveHk6Oml0ZW1Gb3JJ RChiYWNrRm9yd2FyZEl0ZW1JRCk7CiAgICAgQVNTRVJUKGl0ZW0pOwpAQCAtMTM2Myw3ICsxMzU1 LDcgQEAgdm9pZCBXZWJQYWdlOjpnb0ZvcndhcmQodWludDY0X3QgbmF2aWdhdGlvbklELCB1aW50 NjRfdCBiYWNrRm9yd2FyZEl0ZW1JRCkKIAogdm9pZCBXZWJQYWdlOjpnb0JhY2sodWludDY0X3Qg bmF2aWdhdGlvbklELCB1aW50NjRfdCBiYWNrRm9yd2FyZEl0ZW1JRCkKIHsKLSAgICBTZW5kU3Rv cFJlc3BvbnNpdmVuZXNzVGltZXIgc3RvcHBlcih0aGlzKTsKKyAgICBTZW5kU3RvcFJlc3BvbnNp dmVuZXNzVGltZXIgc3RvcHBlcjsKIAogICAgIEhpc3RvcnlJdGVtKiBpdGVtID0gV2ViQmFja0Zv cndhcmRMaXN0UHJveHk6Oml0ZW1Gb3JJRChiYWNrRm9yd2FyZEl0ZW1JRCk7CiAgICAgQVNTRVJU KGl0ZW0pOwpAQCAtMTM3OCw3ICsxMzcwLDcgQEAgdm9pZCBXZWJQYWdlOjpnb0JhY2sodWludDY0 X3QgbmF2aWdhdGlvbklELCB1aW50NjRfdCBiYWNrRm9yd2FyZEl0ZW1JRCkKIAogdm9pZCBXZWJQ YWdlOjpnb1RvQmFja0ZvcndhcmRJdGVtKHVpbnQ2NF90IG5hdmlnYXRpb25JRCwgdWludDY0X3Qg YmFja0ZvcndhcmRJdGVtSUQpCiB7Ci0gICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0 b3BwZXIodGhpcyk7CisgICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3BwZXI7CiAK ICAgICBIaXN0b3J5SXRlbSogaXRlbSA9IFdlYkJhY2tGb3J3YXJkTGlzdFByb3h5OjppdGVtRm9y SUQoYmFja0ZvcndhcmRJdGVtSUQpOwogICAgIEFTU0VSVChpdGVtKTsKZGlmZiAtLWdpdCBhL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKaW5kZXggOTljMGMwOTI0N2QuLjk1Zjk2MWMwODlmIDEwMDY0NAotLS0gYS9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysg Yi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagpAQCAtNDgzLDYgKzQ4Myw3IEBACiAJCTgzNjFGMTc4MUU2MTBCNEUwMDc1OUIyNSAvKiBs aW5rLXdpdGgtZG93bmxvYWQtYXR0cmlidXRlLXdpdGgtc2xhc2hlcy5odG1sIGluIENvcHkgUmVz b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDgzNjFGMTc3MUU2MTBC MjEwMDc1OUIyNSAvKiBsaW5rLXdpdGgtZG93bmxvYWQtYXR0cmlidXRlLXdpdGgtc2xhc2hlcy5o dG1sICovOyB9OwogCQk4MzdBMzVGMTFEOUExRTdEMDA2NjNDNTcgLyogRG93bmxvYWRSZXF1ZXN0 QmxvYlVSTC5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDgzN0EzNUYwMUQ5QTFFNjQwMDY2M0M1NyAvKiBEb3dubG9hZFJlcXVlc3RCbG9i VVJMLmh0bWwgKi87IH07CiAJCTgzQjZERTZGMUVFNzUyMjEwMDFFNzkyRiAvKiBSZXN0b3JlU2Vz c2lvblN0YXRlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDgzQjZERTZFMUVFNzUyMEYwMDFFNzkyRiAvKiBSZXN0b3JlU2Vzc2lvblN0YXRlLmNwcCAq LzsgfTsKKwkJODNERTEzNEQxRUYxQzUwODAwQzFCMzU1IC8qIFJlc3BvbnNpdmVuZXNzVGltZXIu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gODNERTEz NEMxRUYxQzRGRTAwQzFCMzU1IC8qIFJlc3BvbnNpdmVuZXNzVGltZXIuY3BwICovOyB9OwogCQk4 RTRBODUzNzFFMUQxQUIyMDBGNTNCMEYgLyogR3JpZFBvc2l0aW9uLmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhFNEE4NTM2MUUxRDFBQTEwMEY1M0Iw RiAvKiBHcmlkUG9zaXRpb24uY3BwICovOyB9OwogCQk5MzBBRDQwMjE1MDY5OEQwMDA2Nzk3MEYg LyogbG90cy1vZi10ZXh0Lmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gOTMwQUQ0MDExNTA2OThCMzAwNjc5NzBGIC8qIGxvdHMtb2YtdGV4 dC5odG1sICovOyB9OwogCQk5MzI5QUEyOTFERTNGODFFMDAzQUJEMDcgLyogVGV4dEJyZWFrSXRl cmF0b3IuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g OTMyOUFBMjgxREUzRjgxRTAwM0FCRDA3IC8qIFRleHRCcmVha0l0ZXJhdG9yLmNwcCAqLzsgfTsK QEAgLTEyOTEsNiArMTI5Miw3IEBACiAJCTgzN0EzNUYwMUQ5QTFFNjQwMDY2M0M1NyAvKiBEb3du bG9hZFJlcXVlc3RCbG9iVVJMLmh0bWwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0Lmh0bWw7IHBhdGggPSBEb3du bG9hZFJlcXVlc3RCbG9iVVJMLmh0bWw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTgz QjZERTZFMUVFNzUyMEYwMDFFNzkyRiAvKiBSZXN0b3JlU2Vzc2lvblN0YXRlLmNwcCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFJlc3RvcmVTZXNzaW9uU3RhdGUuY3BwOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4M0I4OEEzMzFDODAwNTZEMDBCQjI0MTggLyog SFRNTFBhcnNlcklkaW9tcy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGgg PSBIVE1MUGFyc2VySWRpb21zLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJODNE RTEzNEMxRUYxQzRGRTAwQzFCMzU1IC8qIFJlc3BvbnNpdmVuZXNzVGltZXIuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVzcG9uc2l2ZW5lc3NUaW1lci5jcHA7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTg2QkQxOTk3MUEyREIwNUIwMDZEQ0YwQSAvKiBS ZWZDb3VudGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFJlZkNv dW50ZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4QTJDNzUwRDE2Q0VEOTU1 MDAyNEYzNTIgLyogUmVzaXplV2luZG93QWZ0ZXJDcmFzaC5jcHAgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5jcHA7IHBhdGggPSBSZXNpemVXaW5kb3dBZnRlckNyYXNoLmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOEEzQUY5M0ExNkM5RUQyNzAwRDI0OEMxIC8qIFJlbG9hZFBh Z2VBZnRlckNyYXNoLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFJl bG9hZFBhZ2VBZnRlckNyYXNoLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTIx ODYsNiArMjE4OCw3IEBACiAJCQkJOEEzQUY5M0ExNkM5RUQyNzAwRDI0OEMxIC8qIFJlbG9hZFBh Z2VBZnRlckNyYXNoLmNwcCAqLywKIAkJCQkyREQ3RDNBOTE3ODIwNUQwMDAyNkUxRTMgLyogUmVz aXplUmV2ZXJzZVBhZ2luYXRlZFdlYlZpZXcuY3BwICovLAogCQkJCThBMkM3NTBEMTZDRUQ5NTUw MDI0RjM1MiAvKiBSZXNpemVXaW5kb3dBZnRlckNyYXNoLmNwcCAqLywKKwkJCQk4M0RFMTM0QzFF RjFDNEZFMDBDMUIzNTUgLyogUmVzcG9uc2l2ZW5lc3NUaW1lci5jcHAgKi8sCiAJCQkJQzBCRDY2 OUMxMzFEM0NGNzAwRTE4RjJBIC8qIFJlc3BvbnNpdmVuZXNzVGltZXJEb2VzbnRGaXJlRWFybHku Y3BwICovLAogCQkJCUMwQkQ2NjlFMTMxRDNDRkYwMEUxOEYyQSAvKiBSZXNwb25zaXZlbmVzc1Rp bWVyRG9lc250RmlyZUVhcmx5X0J1bmRsZS5jcHAgKi8sCiAJCQkJODNCNkRFNkUxRUU3NTIwRjAw MUU3OTJGIC8qIFJlc3RvcmVTZXNzaW9uU3RhdGUuY3BwICovLApAQCAtMjk4MCw2ICsyOTgzLDcg QEAKIAkJCQk3QTk1QkRFMTFFOUJFQzVGMDA4NjU0OTggLyogSW5qZWN0ZWRCdW5kbGVBcHBsZUV2 ZW50LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTUxMDQ3Nzc4MUQyOTkyM0IwMDk3NDdFQiAvKiBJ REJEZWxldGVSZWNvdmVyeS5tbSBpbiBTb3VyY2VzICovLAogCQkJCTUxMTBGQ0ZBMUUwMUNEQjgw MDZGOEQwQiAvKiBJREJJbmRleFVwZ3JhZGVUb1YyLm1tIGluIFNvdXJjZXMgKi8sCisJCQkJODNE RTEzNEQxRUYxQzUwODAwQzFCMzU1IC8qIFJlc3BvbnNpdmVuZXNzVGltZXIuY3BwIGluIFNvdXJj ZXMgKi8sCiAJCQkJNTFBNTg3ODYxRDI3M0FBOTAwNEJBOUFGIC8qIEluZGV4ZWREQkRhdGFiYXNl UHJvY2Vzc0tpbGwubW0gaW4gU291cmNlcyAqLywKIAkJCQk3QzgzRTBCRTFEMEE2NTEzMDBGRUJD RjMgLyogSW5kZXhlZERCTXVsdGlQcm9jZXNzLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJN0M4M0Uw QkYxRDBBNjUyMjAwRkVCQ0YzIC8qIEluZGV4ZWREQlBlcnNpc3RlbmNlLm1tIGluIFNvdXJjZXMg Ki8sCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvUmVzcG9u c2l2ZW5lc3NUaW1lci5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvUmVz cG9uc2l2ZW5lc3NUaW1lci5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAuLjA2ZjgxZDUzZjY5Ci0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXQyL1Jlc3BvbnNpdmVuZXNzVGltZXIuY3BwCkBAIC0wLDAgKzEsOTYgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMTcgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBB TkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQ TEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFV RU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VE IEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBXS19IQVZFX0NfU1BJCisKKyNp bmNsdWRlICJQbGF0Zm9ybVV0aWxpdGllcy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtV2ViVmlldy5o IgorCituYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisKK3N0YXRpYyBib29sIGRpZEZpbmlzaExv YWQgeyBmYWxzZSB9Oworc3RhdGljIGJvb2wgZGlkQmVjb21lVW5yZXNwb25zaXZlIHsgZmFsc2Ug fTsKKworc3RhdGljIHZvaWQgZGlkRmluaXNoTG9hZEZvckZyYW1lKFdLUGFnZVJlZiwgV0tGcmFt ZVJlZiwgV0tUeXBlUmVmLCBjb25zdCB2b2lkKikKK3sKKyAgICBkaWRGaW5pc2hMb2FkID0gdHJ1 ZTsKK30KKworc3RhdGljIHZvaWQgcHJvY2Vzc0RpZEJlY29tZVVucmVzcG9uc2l2ZShXS1BhZ2VS ZWYgcGFnZSwgY29uc3Qgdm9pZCopCit7CisgICAgZGlkQmVjb21lVW5yZXNwb25zaXZlID0gdHJ1 ZTsKK30KKworc3RhdGljIHZvaWQgc2V0UGFnZUxvYWRlckNsaWVudChXS1BhZ2VSZWYgcGFnZSkK K3sKKyAgICBXS1BhZ2VMb2FkZXJDbGllbnRWMCBsb2FkZXJDbGllbnQ7CisgICAgbWVtc2V0KCZs b2FkZXJDbGllbnQsIDAsIHNpemVvZihsb2FkZXJDbGllbnQpKTsKKworICAgIGxvYWRlckNsaWVu dC5iYXNlLnZlcnNpb24gPSAwOworICAgIGxvYWRlckNsaWVudC5kaWRGaW5pc2hMb2FkRm9yRnJh bWUgPSBkaWRGaW5pc2hMb2FkRm9yRnJhbWU7CisgICAgbG9hZGVyQ2xpZW50LnByb2Nlc3NEaWRC ZWNvbWVVbnJlc3BvbnNpdmUgPSBwcm9jZXNzRGlkQmVjb21lVW5yZXNwb25zaXZlOworCisgICAg V0tQYWdlU2V0UGFnZUxvYWRlckNsaWVudChwYWdlLCAmbG9hZGVyQ2xpZW50LmJhc2UpOworfQor CitURVNUKFdlYktpdDIsIFJlc3BvbnNpdmVuZXNzVGltZXJTaG91bGROb3RGaXJlQWZ0ZXJUZWFy RG93bikKK3sKKyAgICBXS1JldGFpblB0cjxXS0NvbnRleHRSZWY+IGNvbnRleHQoQWRvcHRXSywg V0tDb250ZXh0Q3JlYXRlKCkpOworICAgIC8vIFRoZSB0d28gdmlld3MgbmVlZCB0byBzaGFyZSB0 aGUgc2FtZSBXZWJDb250ZW50IHByb2Nlc3MuCisgICAgV0tDb250ZXh0U2V0TWF4aW11bU51bWJl ck9mUHJvY2Vzc2VzKGNvbnRleHQuZ2V0KCksIDEpOworCisgICAgUGxhdGZvcm1XZWJWaWV3IHdl YlZpZXcxKGNvbnRleHQuZ2V0KCkpOworICAgIHNldFBhZ2VMb2FkZXJDbGllbnQod2ViVmlldzEu cGFnZSgpKTsKKworICAgIFdLUGFnZUxvYWRVUkwod2ViVmlldzEucGFnZSgpLCBhZG9wdFdLKFV0 aWw6OmNyZWF0ZVVSTEZvclJlc291cmNlKCJzaW1wbGUiLCAiaHRtbCIpKS5nZXQoKSk7CisgICAg VXRpbDo6cnVuKCZkaWRGaW5pc2hMb2FkKTsKKworICAgIEVYUEVDVF9GQUxTRShkaWRCZWNvbWVV bnJlc3BvbnNpdmUpOworCisgICAgUGxhdGZvcm1XZWJWaWV3IHdlYlZpZXcyKGNvbnRleHQuZ2V0 KCkpOworICAgIHNldFBhZ2VMb2FkZXJDbGllbnQod2ViVmlldzIucGFnZSgpKTsKKworICAgIGRp ZEZpbmlzaExvYWQgPSBmYWxzZTsKKyAgICBXS1BhZ2VMb2FkVVJMKHdlYlZpZXcyLnBhZ2UoKSwg YWRvcHRXSyhVdGlsOjpjcmVhdGVVUkxGb3JSZXNvdXJjZSgic2ltcGxlIiwgImh0bWwiKSkuZ2V0 KCkpOworICAgIFV0aWw6OnJ1bigmZGlkRmluaXNoTG9hZCk7CisKKyAgICBFWFBFQ1RfRkFMU0Uo ZGlkQmVjb21lVW5yZXNwb25zaXZlKTsKKworICAgIC8vIENhbGwgc3RvcExvYWRpbmcoKSBhbmQg Y2xvc2UoKSBvbiB0aGUgZmlyc3QgcGFnZSBpbiBxdWljayBzdWNjZXNzaW9uLgorICAgIFdLUGFn ZVN0b3BMb2FkaW5nKHdlYlZpZXcxLnBhZ2UoKSk7CisgICAgV0tQYWdlQ2xvc2Uod2ViVmlldzEu cGFnZSgpKTsKKworICAgIC8vIFdlIG5lZWQgdG8gd2FpdCBoZXJlIGJlY2F1c2UgaXQgdGFrZXMg MyBzZWNvbmRzIGZvciBhIHByb2Nlc3MgdG8gYmUgcmVjb2duaXplZCBhcyB1bnJlc3BvbnNpdmUu CisgICAgVXRpbDo6c2xlZXAoNCk7CisKKyAgICAvLyBXZSBzaG91bGQgbm90IHJlcG9ydCB0aGUg c2Vjb25kIHBhZ2Ugc2hhcmluZyB0aGUgc2FtZSBwcm9jZXNzIGFzIHVucmVzcG9uc2l2ZS4KKyAg ICBFWFBFQ1RfRkFMU0UoZGlkQmVjb21lVW5yZXNwb25zaXZlKTsKK30KKworfSAvLyBuYW1lc3Bh Y2UgVGVzdFdlYktpdEFQSQorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvY29jb2EvVXRpbGl0aWVzQ29jb2EubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL2NvY29hL1V0 aWxpdGllc0NvY29hLm1tCmluZGV4IDFmNzUzODU0ODUzLi5iYTVhNTJmOWI2ZiAxMDA2NDQKLS0t IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9jb2NvYS9VdGlsaXRpZXNDb2NvYS5tbQorKysgYi9Ub29s cy9UZXN0V2ViS2l0QVBJL2NvY29hL1V0aWxpdGllc0NvY29hLm1tCkBAIC0zNyw3ICszNyw3IEBA IHZvaWQgcnVuKGJvb2wqIGRvbmUpCiAKIHZvaWQgc2xlZXAoZG91YmxlIHNlY29uZHMpCiB7Ci0g ICAgdXNsZWVwKHNlY29uZHMgKiAxMDAwMDAwKTsKKyAgICBbW05TUnVuTG9vcCBjdXJyZW50UnVu TG9vcF0gcnVuVW50aWxEYXRlOltOU0RhdGUgZGF0ZVdpdGhUaW1lSW50ZXJ2YWxTaW5jZU5vdzpz ZWNvbmRzXV07CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFV0aWwK 312922 2017-06-14 14:54:32 -0700 2017-06-14 15:49:45 -0700 Patch bug-173384-20170614145431.patch text/plain 19234 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjE4Mjc3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggYjc5MTBjNzIzZTkyYzA2 ZTAzYjQ1Mjg3ODRlY2UzZjFiN2VlZGU5NS4uN2FiNWUyZGQ4MTdhNjJlMGFkMWI5MGY3ZGVlMDNl YTI2OWQwNDU5MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM5IEBACisyMDE3LTA2LTE0ICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgV2ViS2l0IGZhbHNlbHkgcmVw b3J0cyB0aGF0IGEgd2ViIHByb2Nlc3MgaXMgdW5yZXNwb25zaXZlIGlmIHlvdSBjbG9zZSBhIHBh Z2Ugc2hvcnRseSBhZnRlciBzdG9wcGluZyBhIGxvYWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3MzM4NAorICAgICAgICA8cmRhcjovL3Byb2JsZW0v MzI3MjM3Nzk+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgV2ViS2l0IGZhbHNlbHkgcmVwb3J0cyB0aGF0IGEgd2ViIHByb2Nlc3MgaXMgdW5yZXNwb25z aXZlIGlmIHlvdSBjbG9zZSBhIHBhZ2Ugc2hvcnRseSBhZnRlciBzdG9wcGluZyBhIGxvYWQuCisg ICAgICAgIFRoaXMgaXMgYmVjYXVzZSBXZWJQYWdlUHJveHk6OnN0b3BMb2FkKCkgc3RhcnRzIHRo ZSByZXNwb25zaXZlbmVzcyB0aW1lciBhbmQgZXhwZWN0cyBhIFN0b3BSZXNwb25zaW5lc3NUaW1l cgorICAgICAgICBJUEMgZnJvbSB0aGUgV2ViUHJvY2VzcyB0byBzdG9wIHRoZSB0aW1lciBzbyB3 ZSBkb24ndCByZXBvcnQgdGhlIHByb2Nlc3MgYXMgdW5yZXNwb25zaXZlLiBIb3dldmVyLCBpZgor ICAgICAgICBXZWJQYWdlUHJveHk6OmNsb3NlKCkgaXMgY2FsbGVkIGJlZm9yZSB0aGUgU3RvcFJl c3BvbnNpbmVzc1RpbWVyIElQQyBoYXMgYmVlbiByZWNlaXZlZCwgdGhlIHBhZ2Ugd2lsbCByZW1v dmUKKyAgICAgICAgaXRzZWxmIGZyb20gdGhlIG1lc3NhZ2UgcmVjZWl2ZXIgbWFwIGFuZCB3ZSB3 b3VsZCBubyBsb25nZXIgYmUgYWJsZSB0byByZWNlaXZlIHRoZSBTdG9wUmVzcG9uc2luZXNzVGlt ZXIKKyAgICAgICAgSVBDIGFuZCBzdG9wIHRoZSB0aW1lciwgZXZlbiBpZiB0aGUgV2ViUHJvY2Vz cyBzZW50IGl0IHRvIHRoZSBVSVByb2Nlc3MuCisKKyAgICAgICAgVG8gYWRkcmVzcyB0aGUgaXNz dWUsIHdlIG5vdyBzZW5kIHRoZSBJUEMgTWVzc2FnZSB0byB0aGUgV2ViUHJvY2Vzc1Byb3h5IGlu c3RlYWQgb2YgdGhlIFdlYlBhZ2VQcm94eSwgc28gd2UKKyAgICAgICAgY2FuIHN0b3AgdGhlIHJl c3BvbnNpdmVuZXNzIHRpbWVyLCBldmVuIGFmdGVyIHRoZSBXZWJQYWdlUHJveHkgaGFzIGJlZW4g Y2FsbGVkLgorCisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHA6CisgICAgICAg ICogVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdl UHJveHkubWVzc2FnZXMuaW46CisgICAgICAgICogVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5j cHA6CisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NQcm94eTo6c3RvcFJlc3BvbnNpdmVuZXNz VGltZXIpOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaDoKKyAgICAgICAg KiBVSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5Lm1lc3NhZ2VzLmluOgorICAgICAgICAqIFdlYlBy b2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6U2VuZFN0b3BSZXNw b25zaXZlbmVzc1RpbWVyOjp+U2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyKToKKyAgICAgICAg KFdlYktpdDo6V2ViUGFnZTo6dHJ5Q2xvc2UpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlOjps b2FkUmVxdWVzdCk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2U6OmxvYWREYXRhSW1wbCk6Cisg ICAgICAgIChXZWJLaXQ6OldlYlBhZ2U6OnN0b3BMb2FkaW5nKToKKyAgICAgICAgKFdlYktpdDo6 V2ViUGFnZTo6cmVsb2FkKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZTo6Z29Gb3J3YXJkKToK KyAgICAgICAgKFdlYktpdDo6V2ViUGFnZTo6Z29CYWNrKToKKyAgICAgICAgKFdlYktpdDo6V2Vi UGFnZTo6Z29Ub0JhY2tGb3J3YXJkSXRlbSk6CisKIDIwMTctMDYtMTQgIEpvbmF0aGFuIEJlZGFy ZCAgPGpiZWRhcmRAYXBwbGUuY29tPgogCiAgICAgICAgIENvbmZpZ3VyZSBzY3JlZW4gc2NhbGUg Zm9yIHJ1bm5pbmcgbGF5b3V0IHRlc3RzIG9uIHBsdXMgZGV2aWNlcwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAppbmRleCBlNDQ2YWVhNjhlMTIwMmQwNTUyOGMyZTQw MjczNzQyOWNmZjkzZDAwLi5jZjA2OWMzZDM1YTQ5ZDgxMDdlY2ViZmNjMjA0ZWYzYzc3ZGNkZjJj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcApAQCAtNDk5Niwx MSArNDk5Niw2IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpkaWRSZWNlaXZlRXZlbnQodWludDMyX3Qg b3BhcXVlVHlwZSwgYm9vbCBoYW5kbGVkKQogICAgIH0KIH0KIAotdm9pZCBXZWJQYWdlUHJveHk6 OnN0b3BSZXNwb25zaXZlbmVzc1RpbWVyKCkKLXsKLSAgICBtX3Byb2Nlc3MtPnJlc3BvbnNpdmVu ZXNzVGltZXIoKS5zdG9wKCk7Ci19Ci0KIHZvaWQgV2ViUGFnZVByb3h5Ojp2b2lkQ2FsbGJhY2so dWludDY0X3QgY2FsbGJhY2tJRCkKIHsKICAgICBhdXRvIGNhbGxiYWNrID0gbV9jYWxsYmFja3Mu dGFrZTxWb2lkQ2FsbGJhY2s+KGNhbGxiYWNrSUQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dl YlBhZ2VQcm94eS5oCmluZGV4IDZhNDU3NzRiYWY2OGVkMzE0MjA5MzE3MTVkMDUwNTk2Y2QxNzBl YTUuLmUyMjQ2NDEzY2Y4ZjQxNTE1NThjMGJiZjNlY2FjYTVlMjM1ZGU3MDEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaAorKysgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKQEAgLTE0NDAsNyArMTQ0MCw2IEBAIHByaXZh dGU6CiAgICAgdm9pZCBzZXRDdXJzb3JIaWRkZW5VbnRpbE1vdXNlTW92ZXMoYm9vbCk7CiAKICAg ICB2b2lkIGRpZFJlY2VpdmVFdmVudCh1aW50MzJfdCBvcGFxdWVUeXBlLCBib29sIGhhbmRsZWQp OwotICAgIHZvaWQgc3RvcFJlc3BvbnNpdmVuZXNzVGltZXIoKTsKIAogICAgIHZvaWQgdm9pZENh bGxiYWNrKHVpbnQ2NF90KTsKICAgICB2b2lkIGRhdGFDYWxsYmFjayhjb25zdCBJUEM6OkRhdGFS ZWZlcmVuY2UmLCB1aW50NjRfdCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvV2ViUGFnZVByb3h5Lm1lc3NhZ2VzLmluIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dl YlBhZ2VQcm94eS5tZXNzYWdlcy5pbgppbmRleCA2MGVhYTUyMzgyYjk2ZWM0NTZkZTNkOTVkNGRk YjczYzhjMGFjNTZkLi4yYzljYWM0M2JlNDNiMTQ5NTVjNjVhMDNkMjkwZDkzNzI4NTAzNWIzIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5Lm1lc3NhZ2Vz LmluCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMu aW4KQEAgLTM5LDcgKzM5LDYgQEAgbWVzc2FnZXMgLT4gV2ViUGFnZVByb3h5IHsKICNlbmRpZiAv LyBFTkFCTEUoV0VCR0wpCiAgICAgRGlkQ2hhbmdlVmlld3BvcnRQcm9wZXJ0aWVzKHN0cnVjdCBX ZWJDb3JlOjpWaWV3cG9ydEF0dHJpYnV0ZXMgYXR0cmlidXRlcykKICAgICBEaWRSZWNlaXZlRXZl bnQodWludDMyX3QgdHlwZSwgYm9vbCBoYW5kbGVkKQotICAgIFN0b3BSZXNwb25zaXZlbmVzc1Rp bWVyKCkKICNpZiAhUExBVEZPUk0oSU9TKQogICAgIFNldEN1cnNvcihXZWJDb3JlOjpDdXJzb3Ig Y3Vyc29yKQogICAgIFNldEN1cnNvckhpZGRlblVudGlsTW91c2VNb3Zlcyhib29sIGhpZGRlblVu dGlsTW91c2VNb3ZlcykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQ cm9jZXNzUHJveHkuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94 eS5jcHAKaW5kZXggZjkzMzMxYmFkOGZiZDUxNTU4MmZmMTg2OTVlYThjNDk2NTRmNjllNC4uNDAx OWYyNzMwODg4ZTIxZWZmYTgyZjdjMmZjMGIwNzA1ODhiZDc3ZCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKQEAgLTkzOSw2ICs5MzksMTEgQEAgdm9p ZCBXZWJQcm9jZXNzUHJveHk6OnJlcXVlc3RUZXJtaW5hdGlvbihQcm9jZXNzVGVybWluYXRpb25S ZWFzb24gcmVhc29uKQogICAgICAgICBwYWdlc1tpXS0+cHJvY2Vzc0RpZFRlcm1pbmF0ZShyZWFz b24pOwogfQogCit2b2lkIFdlYlByb2Nlc3NQcm94eTo6c3RvcFJlc3BvbnNpdmVuZXNzVGltZXIo KQoreworICAgIHJlc3BvbnNpdmVuZXNzVGltZXIoKS5zdG9wKCk7Cit9CisKIHZvaWQgV2ViUHJv Y2Vzc1Byb3h5OjplbmFibGVTdWRkZW5UZXJtaW5hdGlvbigpCiB7CiAgICAgaWYgKHN0YXRlKCkg IT0gU3RhdGU6OlJ1bm5pbmcpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv V2ViUHJvY2Vzc1Byb3h5LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1By b3h5LmgKaW5kZXggZmQ5ZDZmM2VhN2YzNTNhN2IyMmQ5MjAyNWY0Y2QxYmJhM2U1OGI3NS4uZDAw YjQ3NDk0OTk3NDM5YzJlOGRlMzQ1MTM1YzkxYTI1MzFhOTIxZSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaApAQCAtMTUxLDYgKzE1MSw4IEBAIHB1YmxpYzoK IAogICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0aW9uKFByb2Nlc3NUZXJtaW5hdGlvblJlYXNvbik7 CiAKKyAgICB2b2lkIHN0b3BSZXNwb25zaXZlbmVzc1RpbWVyKCk7CisKICAgICBSZWZQdHI8QVBJ OjpPYmplY3Q+IHRyYW5zZm9ybUhhbmRsZXNUb09iamVjdHMoQVBJOjpPYmplY3QqKTsKICAgICBz dGF0aWMgUmVmUHRyPEFQSTo6T2JqZWN0PiB0cmFuc2Zvcm1PYmplY3RzVG9IYW5kbGVzKEFQSTo6 T2JqZWN0Kik7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9j ZXNzUHJveHkubWVzc2FnZXMuaW4gYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vz c1Byb3h5Lm1lc3NhZ2VzLmluCmluZGV4IDkzMzc4MzBjMjcxNWI0ODlhNTgyMTY0ZDNmYjU2Njky ZTBhYjUwMGEuLmIyYmI3ODEyMGY1NWU2NDVhNmUyMTI5ZGRkM2Y1MzVkZGVkNDg1YjMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkubWVzc2FnZXMu aW4KKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5tZXNzYWdl cy5pbgpAQCAtNDksNiArNDksOCBAQCBtZXNzYWdlcyAtPiBXZWJQcm9jZXNzUHJveHkgTGVnYWN5 UmVjZWl2ZXIgewogICAgIERpZEV4Y2VlZEluYWN0aXZlTWVtb3J5TGltaXQoKQogICAgIERpZEV4 Y2VlZENQVUxpbWl0KCkKIAorICAgIFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyKCkKKwogICAgIFJl dGFpbkljb25Gb3JQYWdlVVJMKFN0cmluZyBwYWdlVVJMKQogICAgIFJlbGVhc2VJY29uRm9yUGFn ZVVSTChTdHJpbmcgcGFnZVVSTCkKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJv Y2Vzcy9XZWJQYWdlL1dlYlBhZ2UuY3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQ YWdlL1dlYlBhZ2UuY3BwCmluZGV4IGY1MmRhOGUxZjNmOTU5OTdmNTEyYmZlNzg2MGE1NDJhODA4 MDY4NDguLjJlYjY3NWRiMWU5YzlhMGY1MmRhNzBjYzIzZTJjZWZjYjI0Y2ZhNzUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcAorKysgYi9T b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5jcHAKQEAgLTI2NCwxOCAr MjY0LDEwIEBAIHN0YXRpYyBjb25zdCBTZWNvbmRzIG1heGltdW1MYXllclZvbGF0aWxpdHlUaW1l ckludGVydmFsIHsgMl9zIH07CiAKIGNsYXNzIFNlbmRTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lciB7 CiBwdWJsaWM6Ci0gICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyKFdlYlBhZ2UqIHBhZ2Up Ci0gICAgICAgIDogbV9wYWdlKHBhZ2UpCi0gICAgewotICAgIH0KLSAgICAKICAgICB+U2VuZFN0 b3BSZXNwb25zaXZlbmVzc1RpbWVyKCkKICAgICB7Ci0gICAgICAgIG1fcGFnZS0+c2VuZChNZXNz YWdlczo6V2ViUGFnZVByb3h5OjpTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lcigpKTsKKyAgICAgICAg V2ViUHJvY2Vzczo6c2luZ2xldG9uKCkucGFyZW50UHJvY2Vzc0Nvbm5lY3Rpb24oKS0+c2VuZChN ZXNzYWdlczo6V2ViUHJvY2Vzc1Byb3h5OjpTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lcigpLCAwKTsK ICAgICB9Ci0KLXByaXZhdGU6Ci0gICAgV2ViUGFnZSogbV9wYWdlOwogfTsKIAogY2xhc3MgRGVm ZXJyZWRQYWdlRGVzdHJ1Y3RvciB7CkBAIC0xMTgwLDEwICsxMTcyLDEwIEBAIHZvaWQgV2ViUGFn ZTo6Y2xvc2UoKQogCiB2b2lkIFdlYlBhZ2U6OnRyeUNsb3NlKCkKIHsKLSAgICBTZW5kU3RvcFJl c3BvbnNpdmVuZXNzVGltZXIgc3RvcHBlcih0aGlzKTsKKyAgICBTZW5kU3RvcFJlc3BvbnNpdmVu ZXNzVGltZXIgc3RvcHBlcjsKIAogICAgIGlmICghY29yZVBhZ2UoKS0+dXNlcklucHV0QnJpZGdl KCkudHJ5Q2xvc2VQYWdlKCkpIHsKLSAgICAgICAgc2VuZChNZXNzYWdlczo6V2ViUGFnZVByb3h5 OjpTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lcigpKTsKKyAgICAgICAgV2ViUHJvY2Vzczo6c2luZ2xl dG9uKCkucGFyZW50UHJvY2Vzc0Nvbm5lY3Rpb24oKS0+c2VuZChNZXNzYWdlczo6V2ViUHJvY2Vz c1Byb3h5OjpTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lcigpLCAwKTsKICAgICAgICAgcmV0dXJuOwog ICAgIH0KIApAQCAtMTIxMiw3ICsxMjA0LDcgQEAgdm9pZCBXZWJQYWdlOjpwbGF0Zm9ybURpZFJl Y2VpdmVMb2FkUGFyYW1ldGVycyhjb25zdCBMb2FkUGFyYW1ldGVycyYgbG9hZFBhcmFtZXQKIAog dm9pZCBXZWJQYWdlOjpsb2FkUmVxdWVzdChjb25zdCBMb2FkUGFyYW1ldGVycyYgbG9hZFBhcmFt ZXRlcnMpCiB7Ci0gICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3BwZXIodGhpcyk7 CisgICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3BwZXI7CiAKICAgICBtX3BlbmRp bmdOYXZpZ2F0aW9uSUQgPSBsb2FkUGFyYW1ldGVycy5uYXZpZ2F0aW9uSUQ7CiAKQEAgLTEyMzYs NyArMTIyOCw3IEBAIHZvaWQgV2ViUGFnZTo6bG9hZFJlcXVlc3QoY29uc3QgTG9hZFBhcmFtZXRl cnMmIGxvYWRQYXJhbWV0ZXJzKQogCiB2b2lkIFdlYlBhZ2U6OmxvYWREYXRhSW1wbCh1aW50NjRf dCBuYXZpZ2F0aW9uSUQsIFJlZjxTaGFyZWRCdWZmZXI+JiYgc2hhcmVkQnVmZmVyLCBjb25zdCBT dHJpbmcmIE1JTUVUeXBlLCBjb25zdCBTdHJpbmcmIGVuY29kaW5nTmFtZSwgY29uc3QgVVJMJiBi YXNlVVJMLCBjb25zdCBVUkwmIHVucmVhY2hhYmxlVVJMLCBjb25zdCBVc2VyRGF0YSYgdXNlckRh dGEpCiB7Ci0gICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3BwZXIodGhpcyk7Cisg ICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3BwZXI7CiAKICAgICBtX3BlbmRpbmdO YXZpZ2F0aW9uSUQgPSBuYXZpZ2F0aW9uSUQ7CiAKQEAgLTEzMjAsNyArMTMxMiw3IEBAIHZvaWQg V2ViUGFnZTo6c3RvcExvYWRpbmdGcmFtZSh1aW50NjRfdCBmcmFtZUlEKQogCiB2b2lkIFdlYlBh Z2U6OnN0b3BMb2FkaW5nKCkKIHsKLSAgICBTZW5kU3RvcFJlc3BvbnNpdmVuZXNzVGltZXIgc3Rv cHBlcih0aGlzKTsKKyAgICBTZW5kU3RvcFJlc3BvbnNpdmVuZXNzVGltZXIgc3RvcHBlcjsKIAog ICAgIGNvcmVQYWdlKCktPnVzZXJJbnB1dEJyaWRnZSgpLnN0b3BMb2FkaW5nRnJhbWUobV9tYWlu RnJhbWUtPmNvcmVGcmFtZSgpKTsKIH0KQEAgLTEzMzcsNyArMTMyOSw3IEBAIHZvaWQgV2ViUGFn ZTo6c2V0RGVmZXJzTG9hZGluZyhib29sIGRlZmVyc0xvYWRpbmcpCiAKIHZvaWQgV2ViUGFnZTo6 cmVsb2FkKHVpbnQ2NF90IG5hdmlnYXRpb25JRCwgdWludDMyX3QgcmVsb2FkT3B0aW9ucywgY29u c3QgU2FuZGJveEV4dGVuc2lvbjo6SGFuZGxlJiBzYW5kYm94RXh0ZW5zaW9uSGFuZGxlKQogewot ICAgIFNlbmRTdG9wUmVzcG9uc2l2ZW5lc3NUaW1lciBzdG9wcGVyKHRoaXMpOworICAgIFNlbmRT dG9wUmVzcG9uc2l2ZW5lc3NUaW1lciBzdG9wcGVyOwogCiAgICAgQVNTRVJUKCFtX21haW5GcmFt ZS0+Y29yZUZyYW1lKCktPmxvYWRlcigpLmZyYW1lSGFzTG9hZGVkKCkgfHwgIW1fcGVuZGluZ05h dmlnYXRpb25JRCk7CiAgICAgbV9wZW5kaW5nTmF2aWdhdGlvbklEID0gbmF2aWdhdGlvbklEOwpA QCAtMTM0OCw3ICsxMzQwLDcgQEAgdm9pZCBXZWJQYWdlOjpyZWxvYWQodWludDY0X3QgbmF2aWdh dGlvbklELCB1aW50MzJfdCByZWxvYWRPcHRpb25zLCBjb25zdCBTYW5kYm8KIAogdm9pZCBXZWJQ YWdlOjpnb0ZvcndhcmQodWludDY0X3QgbmF2aWdhdGlvbklELCB1aW50NjRfdCBiYWNrRm9yd2Fy ZEl0ZW1JRCkKIHsKLSAgICBTZW5kU3RvcFJlc3BvbnNpdmVuZXNzVGltZXIgc3RvcHBlcih0aGlz KTsKKyAgICBTZW5kU3RvcFJlc3BvbnNpdmVuZXNzVGltZXIgc3RvcHBlcjsKIAogICAgIEhpc3Rv cnlJdGVtKiBpdGVtID0gV2ViQmFja0ZvcndhcmRMaXN0UHJveHk6Oml0ZW1Gb3JJRChiYWNrRm9y d2FyZEl0ZW1JRCk7CiAgICAgQVNTRVJUKGl0ZW0pOwpAQCAtMTM2Myw3ICsxMzU1LDcgQEAgdm9p ZCBXZWJQYWdlOjpnb0ZvcndhcmQodWludDY0X3QgbmF2aWdhdGlvbklELCB1aW50NjRfdCBiYWNr Rm9yd2FyZEl0ZW1JRCkKIAogdm9pZCBXZWJQYWdlOjpnb0JhY2sodWludDY0X3QgbmF2aWdhdGlv bklELCB1aW50NjRfdCBiYWNrRm9yd2FyZEl0ZW1JRCkKIHsKLSAgICBTZW5kU3RvcFJlc3BvbnNp dmVuZXNzVGltZXIgc3RvcHBlcih0aGlzKTsKKyAgICBTZW5kU3RvcFJlc3BvbnNpdmVuZXNzVGlt ZXIgc3RvcHBlcjsKIAogICAgIEhpc3RvcnlJdGVtKiBpdGVtID0gV2ViQmFja0ZvcndhcmRMaXN0 UHJveHk6Oml0ZW1Gb3JJRChiYWNrRm9yd2FyZEl0ZW1JRCk7CiAgICAgQVNTRVJUKGl0ZW0pOwpA QCAtMTM3OCw3ICsxMzcwLDcgQEAgdm9pZCBXZWJQYWdlOjpnb0JhY2sodWludDY0X3QgbmF2aWdh dGlvbklELCB1aW50NjRfdCBiYWNrRm9yd2FyZEl0ZW1JRCkKIAogdm9pZCBXZWJQYWdlOjpnb1Rv QmFja0ZvcndhcmRJdGVtKHVpbnQ2NF90IG5hdmlnYXRpb25JRCwgdWludDY0X3QgYmFja0Zvcndh cmRJdGVtSUQpCiB7Ci0gICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3BwZXIodGhp cyk7CisgICAgU2VuZFN0b3BSZXNwb25zaXZlbmVzc1RpbWVyIHN0b3BwZXI7CiAKICAgICBIaXN0 b3J5SXRlbSogaXRlbSA9IFdlYkJhY2tGb3J3YXJkTGlzdFByb3h5OjppdGVtRm9ySUQoYmFja0Zv cndhcmRJdGVtSUQpOwogICAgIEFTU0VSVChpdGVtKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5n ZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBlY2ZhNGVlNDQ3ZWE0NmFlMmJiYjUzZmRmMzUw YTNiOTdiMjUyOGM0Li5hZGE1YWZiY2E1OGM5YjliMWZiNzhmM2Y0YzZlNDEzOTEzYWMxN2ZmIDEw MDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMjAgQEAKKzIwMTctMDYtMTQgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKwor ICAgICAgICBXZWJLaXQgZmFsc2VseSByZXBvcnRzIHRoYXQgYSB3ZWIgcHJvY2VzcyBpcyB1bnJl c3BvbnNpdmUgaWYgeW91IGNsb3NlIGEgcGFnZSBzaG9ydGx5IGFmdGVyIHN0b3BwaW5nIGEgbG9h ZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTczMzg0 CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8zMjcyMzc3OT4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQ SS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mi9SZXNwb25zaXZlbmVzc1RpbWVyLmNwcDogQWRkZWQuCisgICAgICAgIEFkZCBB UEkgdGVzdCBjb3ZlcmFnZS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvY29jb2EvVXRpbGl0 aWVzQ29jb2EubW06CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpVdGlsOjpzbGVlcCk6CisgICAg ICAgIFVwZGF0ZSBpbXBsZW1lbnRhdGlvbiBvZiBVdGlsOjpzbGVlcCgpIHNvIHRoYXQgd2UgYWN0 dWFsbHkgcnVuIHRoZSBydW4gbG9vcC4KKyAgICAgICAgT3RoZXJ3aXNlLCB3ZSBkb24ndCBwcm9j ZXNzIGV2ZW50cyB3aGlsZSBzbGVlcGluZy4KKwogMjAxNy0wNi0xNCAgVGltIEhvcnRvbiAgPHRp bW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KIAogICAgICAgICBXS0NvbnRlbnRWaWV3RWRpdGluZ0Fj dGlvbnMgQVBJIHRlc3QgYWx3YXlzIGZhaWxzCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDk5 YzBjMDkyNDdkMDNhY2VlZTYzM2I2OTYxMDM2YTQwODRkNDJlNDkuLjk1Zjk2MWMwODlmYjVlZTkw NTUyODM4OGJhNmU0OTgwYzQzNTQzOTUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv VGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC00ODMs NiArNDgzLDcgQEAKIAkJODM2MUYxNzgxRTYxMEI0RTAwNzU5QjI1IC8qIGxpbmstd2l0aC1kb3du bG9hZC1hdHRyaWJ1dGUtd2l0aC1zbGFzaGVzLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gODM2MUYxNzcxRTYxMEIyMTAwNzU5QjI1IC8q IGxpbmstd2l0aC1kb3dubG9hZC1hdHRyaWJ1dGUtd2l0aC1zbGFzaGVzLmh0bWwgKi87IH07CiAJ CTgzN0EzNUYxMUQ5QTFFN0QwMDY2M0M1NyAvKiBEb3dubG9hZFJlcXVlc3RCbG9iVVJMLmh0bWwg aW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gODM3 QTM1RjAxRDlBMUU2NDAwNjYzQzU3IC8qIERvd25sb2FkUmVxdWVzdEJsb2JVUkwuaHRtbCAqLzsg fTsKIAkJODNCNkRFNkYxRUU3NTIyMTAwMUU3OTJGIC8qIFJlc3RvcmVTZXNzaW9uU3RhdGUuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gODNCNkRFNkUx RUU3NTIwRjAwMUU3OTJGIC8qIFJlc3RvcmVTZXNzaW9uU3RhdGUuY3BwICovOyB9OworCQk4M0RF MTM0RDFFRjFDNTA4MDBDMUIzNTUgLyogUmVzcG9uc2l2ZW5lc3NUaW1lci5jcHAgaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4M0RFMTM0QzFFRjFDNEZFMDBD MUIzNTUgLyogUmVzcG9uc2l2ZW5lc3NUaW1lci5jcHAgKi87IH07CiAJCThFNEE4NTM3MUUxRDFB QjIwMEY1M0IwRiAvKiBHcmlkUG9zaXRpb24uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gOEU0QTg1MzYxRTFEMUFBMTAwRjUzQjBGIC8qIEdyaWRQb3Np dGlvbi5jcHAgKi87IH07CiAJCTkzMEFENDAyMTUwNjk4RDAwMDY3OTcwRiAvKiBsb3RzLW9mLXRl eHQuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA5MzBBRDQwMTE1MDY5OEIzMDA2Nzk3MEYgLyogbG90cy1vZi10ZXh0Lmh0bWwgKi87IH07 CiAJCTkzMjlBQTI5MURFM0Y4MUUwMDNBQkQwNyAvKiBUZXh0QnJlYWtJdGVyYXRvci5jcHAgaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzI5QUEyODFERTNG ODFFMDAzQUJEMDcgLyogVGV4dEJyZWFrSXRlcmF0b3IuY3BwICovOyB9OwpAQCAtMTI5MSw2ICsx MjkyLDcgQEAKIAkJODM3QTM1RjAxRDlBMUU2NDAwNjYzQzU3IC8qIERvd25sb2FkUmVxdWVzdEJs b2JVUkwuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9IERvd25sb2FkUmVxdWVzdEJs b2JVUkwuaHRtbDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJODNCNkRFNkUxRUU3NTIw RjAwMUU3OTJGIC8qIFJlc3RvcmVTZXNzaW9uU3RhdGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gUmVzdG9yZVNlc3Npb25TdGF0ZS5jcHA7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCTgzQjg4QTMzMUM4MDA1NkQwMEJCMjQxOCAvKiBIVE1MUGFyc2VySWRp b21zLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEhUTUxQYXJzZXJJ ZGlvbXMuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk4M0RFMTM0QzFFRjFDNEZF MDBDMUIzNTUgLyogUmVzcG9uc2l2ZW5lc3NUaW1lci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmNwcC5jcHA7IHBhdGggPSBSZXNwb25zaXZlbmVzc1RpbWVyLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJODZCRDE5OTcxQTJEQjA1QjAwNkRDRjBBIC8qIFJlZkNvdW50ZXIuY3Bw ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVmQ291bnRlci5jcHA7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCThBMkM3NTBEMTZDRUQ5NTUwMDI0RjM1MiAvKiBS ZXNpemVXaW5kb3dBZnRlckNyYXNoLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IFJlc2l6ZVdpbmRvd0FmdGVyQ3Jhc2guY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk4QTNBRjkzQTE2QzlFRDI3MDBEMjQ4QzEgLyogUmVsb2FkUGFnZUFmdGVyQ3Jhc2gu Y3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVsb2FkUGFnZUFmdGVy Q3Jhc2guY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMjE4Niw2ICsyMTg4LDcg QEAKIAkJCQk4QTNBRjkzQTE2QzlFRDI3MDBEMjQ4QzEgLyogUmVsb2FkUGFnZUFmdGVyQ3Jhc2gu Y3BwICovLAogCQkJCTJERDdEM0E5MTc4MjA1RDAwMDI2RTFFMyAvKiBSZXNpemVSZXZlcnNlUGFn aW5hdGVkV2ViVmlldy5jcHAgKi8sCiAJCQkJOEEyQzc1MEQxNkNFRDk1NTAwMjRGMzUyIC8qIFJl c2l6ZVdpbmRvd0FmdGVyQ3Jhc2guY3BwICovLAorCQkJCTgzREUxMzRDMUVGMUM0RkUwMEMxQjM1 NSAvKiBSZXNwb25zaXZlbmVzc1RpbWVyLmNwcCAqLywKIAkJCQlDMEJENjY5QzEzMUQzQ0Y3MDBF MThGMkEgLyogUmVzcG9uc2l2ZW5lc3NUaW1lckRvZXNudEZpcmVFYXJseS5jcHAgKi8sCiAJCQkJ QzBCRDY2OUUxMzFEM0NGRjAwRTE4RjJBIC8qIFJlc3BvbnNpdmVuZXNzVGltZXJEb2VzbnRGaXJl RWFybHlfQnVuZGxlLmNwcCAqLywKIAkJCQk4M0I2REU2RTFFRTc1MjBGMDAxRTc5MkYgLyogUmVz dG9yZVNlc3Npb25TdGF0ZS5jcHAgKi8sCkBAIC0yOTgwLDYgKzI5ODMsNyBAQAogCQkJCTdBOTVC REUxMUU5QkVDNUYwMDg2NTQ5OCAvKiBJbmplY3RlZEJ1bmRsZUFwcGxlRXZlbnQuY3BwIGluIFNv dXJjZXMgKi8sCiAJCQkJNTEwNDc3NzgxRDI5OTIzQjAwOTc0N0VCIC8qIElEQkRlbGV0ZVJlY292 ZXJ5Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJNTExMEZDRkExRTAxQ0RCODAwNkY4RDBCIC8qIElE QkluZGV4VXBncmFkZVRvVjIubW0gaW4gU291cmNlcyAqLywKKwkJCQk4M0RFMTM0RDFFRjFDNTA4 MDBDMUIzNTUgLyogUmVzcG9uc2l2ZW5lc3NUaW1lci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk1 MUE1ODc4NjFEMjczQUE5MDA0QkE5QUYgLyogSW5kZXhlZERCRGF0YWJhc2VQcm9jZXNzS2lsbC5t bSBpbiBTb3VyY2VzICovLAogCQkJCTdDODNFMEJFMUQwQTY1MTMwMEZFQkNGMyAvKiBJbmRleGVk REJNdWx0aVByb2Nlc3MubW0gaW4gU291cmNlcyAqLywKIAkJCQk3QzgzRTBCRjFEMEE2NTIyMDBG RUJDRjMgLyogSW5kZXhlZERCUGVyc2lzdGVuY2UubW0gaW4gU291cmNlcyAqLywKZGlmZiAtLWdp dCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9SZXNwb25zaXZlbmVzc1RpbWVy LmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9SZXNwb25zaXZlbmVzc1Rp bWVyLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi4wNmY4MWQ1M2Y2OWY3MTZhMWE4ZjgyYmJhNDQ3MWU1MmY4N2Vl Y2Q0Ci0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy L1Jlc3BvbnNpdmVuZXNzVGltZXIuY3BwCkBAIC0wLDAgKzEsOTYgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTcgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRS SUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICog UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJ VFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkg VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBXS19IQVZFX0NfU1BJCisKKyNpbmNsdWRlICJQbGF0 Zm9ybVV0aWxpdGllcy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtV2ViVmlldy5oIgorCituYW1lc3Bh Y2UgVGVzdFdlYktpdEFQSSB7CisKK3N0YXRpYyBib29sIGRpZEZpbmlzaExvYWQgeyBmYWxzZSB9 Oworc3RhdGljIGJvb2wgZGlkQmVjb21lVW5yZXNwb25zaXZlIHsgZmFsc2UgfTsKKworc3RhdGlj IHZvaWQgZGlkRmluaXNoTG9hZEZvckZyYW1lKFdLUGFnZVJlZiwgV0tGcmFtZVJlZiwgV0tUeXBl UmVmLCBjb25zdCB2b2lkKikKK3sKKyAgICBkaWRGaW5pc2hMb2FkID0gdHJ1ZTsKK30KKworc3Rh dGljIHZvaWQgcHJvY2Vzc0RpZEJlY29tZVVucmVzcG9uc2l2ZShXS1BhZ2VSZWYgcGFnZSwgY29u c3Qgdm9pZCopCit7CisgICAgZGlkQmVjb21lVW5yZXNwb25zaXZlID0gdHJ1ZTsKK30KKworc3Rh dGljIHZvaWQgc2V0UGFnZUxvYWRlckNsaWVudChXS1BhZ2VSZWYgcGFnZSkKK3sKKyAgICBXS1Bh Z2VMb2FkZXJDbGllbnRWMCBsb2FkZXJDbGllbnQ7CisgICAgbWVtc2V0KCZsb2FkZXJDbGllbnQs IDAsIHNpemVvZihsb2FkZXJDbGllbnQpKTsKKworICAgIGxvYWRlckNsaWVudC5iYXNlLnZlcnNp b24gPSAwOworICAgIGxvYWRlckNsaWVudC5kaWRGaW5pc2hMb2FkRm9yRnJhbWUgPSBkaWRGaW5p c2hMb2FkRm9yRnJhbWU7CisgICAgbG9hZGVyQ2xpZW50LnByb2Nlc3NEaWRCZWNvbWVVbnJlc3Bv bnNpdmUgPSBwcm9jZXNzRGlkQmVjb21lVW5yZXNwb25zaXZlOworCisgICAgV0tQYWdlU2V0UGFn ZUxvYWRlckNsaWVudChwYWdlLCAmbG9hZGVyQ2xpZW50LmJhc2UpOworfQorCitURVNUKFdlYktp dDIsIFJlc3BvbnNpdmVuZXNzVGltZXJTaG91bGROb3RGaXJlQWZ0ZXJUZWFyRG93bikKK3sKKyAg ICBXS1JldGFpblB0cjxXS0NvbnRleHRSZWY+IGNvbnRleHQoQWRvcHRXSywgV0tDb250ZXh0Q3Jl YXRlKCkpOworICAgIC8vIFRoZSB0d28gdmlld3MgbmVlZCB0byBzaGFyZSB0aGUgc2FtZSBXZWJD b250ZW50IHByb2Nlc3MuCisgICAgV0tDb250ZXh0U2V0TWF4aW11bU51bWJlck9mUHJvY2Vzc2Vz KGNvbnRleHQuZ2V0KCksIDEpOworCisgICAgUGxhdGZvcm1XZWJWaWV3IHdlYlZpZXcxKGNvbnRl eHQuZ2V0KCkpOworICAgIHNldFBhZ2VMb2FkZXJDbGllbnQod2ViVmlldzEucGFnZSgpKTsKKwor ICAgIFdLUGFnZUxvYWRVUkwod2ViVmlldzEucGFnZSgpLCBhZG9wdFdLKFV0aWw6OmNyZWF0ZVVS TEZvclJlc291cmNlKCJzaW1wbGUiLCAiaHRtbCIpKS5nZXQoKSk7CisgICAgVXRpbDo6cnVuKCZk aWRGaW5pc2hMb2FkKTsKKworICAgIEVYUEVDVF9GQUxTRShkaWRCZWNvbWVVbnJlc3BvbnNpdmUp OworCisgICAgUGxhdGZvcm1XZWJWaWV3IHdlYlZpZXcyKGNvbnRleHQuZ2V0KCkpOworICAgIHNl dFBhZ2VMb2FkZXJDbGllbnQod2ViVmlldzIucGFnZSgpKTsKKworICAgIGRpZEZpbmlzaExvYWQg PSBmYWxzZTsKKyAgICBXS1BhZ2VMb2FkVVJMKHdlYlZpZXcyLnBhZ2UoKSwgYWRvcHRXSyhVdGls OjpjcmVhdGVVUkxGb3JSZXNvdXJjZSgic2ltcGxlIiwgImh0bWwiKSkuZ2V0KCkpOworICAgIFV0 aWw6OnJ1bigmZGlkRmluaXNoTG9hZCk7CisKKyAgICBFWFBFQ1RfRkFMU0UoZGlkQmVjb21lVW5y ZXNwb25zaXZlKTsKKworICAgIC8vIENhbGwgc3RvcExvYWRpbmcoKSBhbmQgY2xvc2UoKSBvbiB0 aGUgZmlyc3QgcGFnZSBpbiBxdWljayBzdWNjZXNzaW9uLgorICAgIFdLUGFnZVN0b3BMb2FkaW5n KHdlYlZpZXcxLnBhZ2UoKSk7CisgICAgV0tQYWdlQ2xvc2Uod2ViVmlldzEucGFnZSgpKTsKKwor ICAgIC8vIFdlIG5lZWQgdG8gd2FpdCBoZXJlIGJlY2F1c2UgaXQgdGFrZXMgMyBzZWNvbmRzIGZv ciBhIHByb2Nlc3MgdG8gYmUgcmVjb2duaXplZCBhcyB1bnJlc3BvbnNpdmUuCisgICAgVXRpbDo6 c2xlZXAoNCk7CisKKyAgICAvLyBXZSBzaG91bGQgbm90IHJlcG9ydCB0aGUgc2Vjb25kIHBhZ2Ug c2hhcmluZyB0aGUgc2FtZSBwcm9jZXNzIGFzIHVucmVzcG9uc2l2ZS4KKyAgICBFWFBFQ1RfRkFM U0UoZGlkQmVjb21lVW5yZXNwb25zaXZlKTsKK30KKworfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktp dEFQSQorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvY29jb2EvVXRp bGl0aWVzQ29jb2EubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL2NvY29hL1V0aWxpdGllc0NvY29h Lm1tCmluZGV4IDFmNzUzODU0ODUzMGYyNzhmNDdmNzBhMTYyMjZkYTYzZmZiMWZkZTYuLmJhNWE1 MmY5YjZmYTc3ODc3ODdjMmMxM2YwZGRhZDZkODg1NDdjZDggMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvY29jb2EvVXRpbGl0aWVzQ29jb2EubW0KKysrIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9jb2NvYS9VdGlsaXRpZXNDb2NvYS5tbQpAQCAtMzcsNyArMzcsNyBAQCB2b2lkIHJ1bihi b29sKiBkb25lKQogCiB2b2lkIHNsZWVwKGRvdWJsZSBzZWNvbmRzKQogewotICAgIHVzbGVlcChz ZWNvbmRzICogMTAwMDAwMCk7CisgICAgW1tOU1J1bkxvb3AgY3VycmVudFJ1bkxvb3BdIHJ1blVu dGlsRGF0ZTpbTlNEYXRlIGRhdGVXaXRoVGltZUludGVydmFsU2luY2VOb3c6c2Vjb25kc11dOwog fQogCiB9IC8vIG5hbWVzcGFjZSBVdGlsCg==