212678 2020-06-02 18:16:24 -0700 REGRESSION (r262212): [ iOS Debug wk2 ] ASSERTION FAILED: !isSynchronous() || !m_synchronousLoadData->delayedReply in WebKit::NetworkResourceLoader 2020-06-04 15:55:04 -0700 1 1 1 Unclassified WebKit WebKit Misc. WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 katherine_cheney katherine_cheney achristensen cdumez youennf oldest_to_newest 1658531 0 katherine_cheney 2020-06-02 18:16:24 -0700 This test started flaky crashing after r262212 1658532 1 katherine_cheney 2020-06-02 18:16:46 -0700 <rdar://problem/63797758> 1658548 2 cdumez 2020-06-02 18:41:29 -0700 From stderr, we can see: Failed to load about:blank, terminating process and trying again. ASSERTION FAILED: !isSynchronous() || !m_synchronousLoadData->delayedReply /Volumes/Data/worker/build/OpenSource/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp(137) : virtual WebKit::NetworkResourceLoader::~NetworkResourceLoader() 1 0x1262664c9 WTFCrash 2 0x119f32e3b WTFCrashWithInfo(int, char const*, char const*, int) 3 0x11a58f88d WebKit::NetworkResourceLoader::~NetworkResourceLoader() 4 0x11a58fcd5 WebKit::NetworkResourceLoader::~NetworkResourceLoader() 5 0x11a58fd5c WebKit::NetworkResourceLoader::~NetworkResourceLoader() 6 0x11a1c250f std::__1::default_delete<WebKit::NetworkResourceLoader>::operator()(WebKit::NetworkResourceLoader*) const 7 0x11a1c24d2 WTF::RefCounted<WebKit::NetworkResourceLoader, std::__1::default_delete<WebKit::NetworkResourceLoader> >::deref() const 8 0x11a53bef7 void WTF::derefIfNotNull<WebKit::NetworkResourceLoader>(WebKit::NetworkResourceLoader*) 9 0x11a53beb9 WTF::RefPtr<WebKit::NetworkResourceLoader, WTF::DumbPtrTraits<WebKit::NetworkResourceLoader> >::~RefPtr() 10 0x11a514cb5 WTF::RefPtr<WebKit::NetworkResourceLoader, WTF::DumbPtrTraits<WebKit::NetworkResourceLoader> >::~RefPtr() 11 0x11a58b158 WebKit::NetworkResourceLoadMap::remove(unsigned long long) 12 0x11a5149a3 WebKit::NetworkConnectionToWebProcess::didCleanupResourceLoader(WebKit::NetworkResourceLoader&) 13 0x11a595d28 WebKit::NetworkResourceLoader::cleanup(WebKit::NetworkResourceLoader::LoadResult) 14 0x11a596e9f WebKit::NetworkResourceLoader::abort() 15 0x11a515ce6 WebKit::NetworkConnectionToWebProcess::didClose(IPC::Connection&) 16 0x119fc26f7 IPC::Connection::connectionDidClose()::$_6::operator()() 17 0x119fc25ee WTF::Detail::CallableWrapper<IPC::Connection::connectionDidClose()::$_6, void>::call() 18 0x12628ec32 WTF::Function<void ()>::operator()() const 19 0x1262fece8 WTF::RunLoop::performWork() 20 0x1262ff6b1 WTF::RunLoop::performWork(void*) 21 0x10f4b4c71 __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__ 22 0x10f4b4b9c __CFRunLoopDoSource0 23 0x10f4b4374 __CFRunLoopDoSources0 24 0x10f4aef6e __CFRunLoopRun 25 0x10f4ae884 CFRunLoopRunSpecific 26 0x10ed77831 -[NSRunLoop(NSRunLoop) runMode:beforeDate:] 27 0x10ed77a45 -[NSRunLoop(NSRunLoop) run] 28 0x1110fa5ae _xpc_objc_main 29 0x1110fc976 xpc_main 30 0x11a6ae27b WebKit::XPCServiceMain(int, char const**) 31 0x11bb3beab WKXPCServiceMain LEAK: 3 WebPageProxy So the WebProcess appears to be unresponsive and at least failing to load about:blank before (or after) the test. As a result, WebKitTestRunner terminates the WebContent process. The termination of the WebContent process triggers some logic in the network process which ends up hitting the assertion. Given the assertion and the test, this is likely related to terminating a WebContent process while a synchronous XHR is going on. 1658766 3 katherine_cheney 2020-06-03 10:16:42 -0700 Since this was caused by r262212, I'm guessing it has something to do with clearing the bundle identifier in the network process between tests. 1659163 4 401040 katherine_cheney 2020-06-04 10:48:47 -0700 Created attachment 401040 Patch 1659171 5 401040 cdumez 2020-06-04 10:55:14 -0700 Comment on attachment 401040 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401040&action=review > Source/WebKit/NetworkProcess/NetworkProcess.cpp:2769 > WebCore::clearApplicationBundleIdentifierTestingOverride(); If this clears an "override", then why do we need to set the identifier again then? From implementation, it looks like override and actual identifier are stored separately. Therefore, once the override is gone, I am unclear why we don't automatically go back to using the default one.. > Source/WebKit/NetworkProcess/NetworkProcess.h:359 > + void resetBundleIdentifierTesting(String&&, CompletionHandler<void()>&&); Seems like this should be "ForTesting", not "Testing". 1659179 6 401040 katherine_cheney 2020-06-04 10:59:43 -0700 Comment on attachment 401040 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401040&action=review >> Source/WebKit/NetworkProcess/NetworkProcess.cpp:2769 >> WebCore::clearApplicationBundleIdentifierTestingOverride(); > > If this clears an "override", then why do we need to set the identifier again then? From implementation, it looks like override and actual identifier are stored separately. Therefore, once the override is gone, I am unclear why we don't automatically go back to using the default one.. The bundle ID in the network process is set to the UI process bundle identifier in NetworkProcess::platformInitializeNetworkProcessCocoa(). Clearing it sets it back to com.apple.WebKit.Networking instead of com.apple.WebKitTestRunner. 1659186 7 cdumez 2020-06-04 11:04:21 -0700 (In reply to katherine_cheney from comment #6) > Comment on attachment 401040 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=401040&action=review > > >> Source/WebKit/NetworkProcess/NetworkProcess.cpp:2769 > >> WebCore::clearApplicationBundleIdentifierTestingOverride(); > > > > If this clears an "override", then why do we need to set the identifier again then? From implementation, it looks like override and actual identifier are stored separately. Therefore, once the override is gone, I am unclear why we don't automatically go back to using the default one.. > > The bundle ID in the network process is set to the UI process bundle > identifier in NetworkProcess::platformInitializeNetworkProcessCocoa(). > Clearing it sets it back to com.apple.WebKit.Networking instead of > com.apple.WebKitTestRunner. This all seems to imply a bug somewhere else. When the network process launches, it should set its bundle identifier based on what the UIProcess tell it. Then if tests need to change this identifier, we should store the new value from the tests in this override variable (not overwrite the one the UIProcess provided). Then in between tests, it should be sufficient to clear the override. Override -> used for testing NonOverride -> never used for testing 1659195 8 katherine_cheney 2020-06-04 11:11:16 -0700 (In reply to Chris Dumez from comment #7) > (In reply to katherine_cheney from comment #6) > > Comment on attachment 401040 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=401040&action=review > > > > >> Source/WebKit/NetworkProcess/NetworkProcess.cpp:2769 > > >> WebCore::clearApplicationBundleIdentifierTestingOverride(); > > > > > > If this clears an "override", then why do we need to set the identifier again then? From implementation, it looks like override and actual identifier are stored separately. Therefore, once the override is gone, I am unclear why we don't automatically go back to using the default one.. > > > > The bundle ID in the network process is set to the UI process bundle > > identifier in NetworkProcess::platformInitializeNetworkProcessCocoa(). > > Clearing it sets it back to com.apple.WebKit.Networking instead of > > com.apple.WebKitTestRunner. > > This all seems to imply a bug somewhere else. When the network process > launches, it should set its bundle identifier based on what the UIProcess > tell it. Then if tests need to change this identifier, we should store the > new value from the tests in this override variable (not overwrite the one > the UIProcess provided). Then in between tests, it should be sufficient to > clear the override. > > Override -> used for testing > NonOverride -> never used for testing I see your point. The problem is, right now both tests and non-tests use the same setter, so there is no way to distinguish when a test is setting the identifier. I can add a new function to set the identifier for tests only, then store the non-test value so when we clear the override we can set it back to that value. 1659211 9 cdumez 2020-06-04 11:33:08 -0700 (In reply to katherine_cheney from comment #8) > (In reply to Chris Dumez from comment #7) > > (In reply to katherine_cheney from comment #6) > > > Comment on attachment 401040 [details] > > > Patch > > > > > > View in context: > > > https://bugs.webkit.org/attachment.cgi?id=401040&action=review > > > > > > >> Source/WebKit/NetworkProcess/NetworkProcess.cpp:2769 > > > >> WebCore::clearApplicationBundleIdentifierTestingOverride(); > > > > > > > > If this clears an "override", then why do we need to set the identifier again then? From implementation, it looks like override and actual identifier are stored separately. Therefore, once the override is gone, I am unclear why we don't automatically go back to using the default one.. > > > > > > The bundle ID in the network process is set to the UI process bundle > > > identifier in NetworkProcess::platformInitializeNetworkProcessCocoa(). > > > Clearing it sets it back to com.apple.WebKit.Networking instead of > > > com.apple.WebKitTestRunner. > > > > This all seems to imply a bug somewhere else. When the network process > > launches, it should set its bundle identifier based on what the UIProcess > > tell it. Then if tests need to change this identifier, we should store the > > new value from the tests in this override variable (not overwrite the one > > the UIProcess provided). Then in between tests, it should be sufficient to > > clear the override. > > > > Override -> used for testing > > NonOverride -> never used for testing > > I see your point. The problem is, right now both tests and non-tests use the > same setter, so there is no way to distinguish when a test is setting the > identifier. I can add a new function to set the identifier for tests only, > then store the non-test value so when we clear the override we can set it > back to that value. Why do we have a concept of override then? If both tests and normal usage end up setting the same variable? Feels like this code needs to be refactored one way or another. Either no override and we use a single variable, or a different method for testing that sets the override but not the real value. 1659273 10 katherine_cheney 2020-06-04 13:02:55 -0700 (In reply to Chris Dumez from comment #9) > (In reply to katherine_cheney from comment #8) > > (In reply to Chris Dumez from comment #7) > > > (In reply to katherine_cheney from comment #6) > > > > Comment on attachment 401040 [details] > > > > Patch > > > > > > > > View in context: > > > > https://bugs.webkit.org/attachment.cgi?id=401040&action=review > > > > > > > > >> Source/WebKit/NetworkProcess/NetworkProcess.cpp:2769 > > > > >> WebCore::clearApplicationBundleIdentifierTestingOverride(); > > > > > > > > > > If this clears an "override", then why do we need to set the identifier again then? From implementation, it looks like override and actual identifier are stored separately. Therefore, once the override is gone, I am unclear why we don't automatically go back to using the default one.. > > > > > > > > The bundle ID in the network process is set to the UI process bundle > > > > identifier in NetworkProcess::platformInitializeNetworkProcessCocoa(). > > > > Clearing it sets it back to com.apple.WebKit.Networking instead of > > > > com.apple.WebKitTestRunner. > > > > > > This all seems to imply a bug somewhere else. When the network process > > > launches, it should set its bundle identifier based on what the UIProcess > > > tell it. Then if tests need to change this identifier, we should store the > > > new value from the tests in this override variable (not overwrite the one > > > the UIProcess provided). Then in between tests, it should be sufficient to > > > clear the override. > > > > > > Override -> used for testing > > > NonOverride -> never used for testing > > > > I see your point. The problem is, right now both tests and non-tests use the > > same setter, so there is no way to distinguish when a test is setting the > > identifier. I can add a new function to set the identifier for tests only, > > then store the non-test value so when we clear the override we can set it > > back to that value. > > Why do we have a concept of override then? If both tests and normal usage > end up setting the same variable? Feels like this code needs to be > refactored one way or another. Either no override and we use a single > variable, or a different method for testing that sets the override but not > the real value. I don't know what the thought process was when writing the code. I agree a separate function for setting the identifier for tests would work. 1659291 11 401072 katherine_cheney 2020-06-04 13:24:52 -0700 Created attachment 401072 Patch 1659366 12 ews-feeder 2020-06-04 15:50:13 -0700 Committed r262582: <https://trac.webkit.org/changeset/262582> All reviewed patches have been landed. Closing bug and clearing flags on attachment 401072. 1659369 13 katherine_cheney 2020-06-04 15:55:04 -0700 The correct radar is: rdar://problem/63884304 401040 2020-06-04 10:48:47 -0700 2020-06-04 13:24:50 -0700 Patch bug-212678-20200604104846.patch text/plain 7498 katherine_cheney U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyMzc5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGQyMzk1NTAwZWNiZTlkMTJm ZmRiMDI5NjJiZTMyNjkwYjI3MjM1ZDguLjBkMDI3MTJjM2YwNzAzYTgyM2VmNGZhNjM0MGQ4YzUx YmZlNzYyZTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjUgQEAKKzIwMjAtMDYtMDQgIEthdGUgQ2hl bmV5ICA8a2F0aGVyaW5lX2NoZW5leUBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAo cjI2MjIxMik6IFsgaU9TIERlYnVnIHdrMiBdIEFTU0VSVElPTiBGQUlMRUQ6ICFpc1N5bmNocm9u b3VzKCkgfHwgIW1fc3luY2hyb25vdXNMb2FkRGF0YS0+ZGVsYXllZFJlcGx5IGluIFdlYktpdDo6 TmV0d29ya1Jlc291cmNlTG9hZGVyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMTI2NzgKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzYzNzk3NzU4Pgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0 ZXN0cywgdGhpcyBzaG91bGQgZml4IGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3QvYWNjZXNzLWNv bnRyb2wtcHJlZmxpZ2h0LWNyZWRlbnRpYWwtc3luYy5odG1sLgorCisgICAgICAgIEluc3RlYWQg b2YgY2xlYXJpbmcgdGhlIGJ1bmRsZSBpZGVudGlmaWVyIGluIHRoZSBuZXR3b3JrIHByb2Nlc3Ms IHdlCisgICAgICAgIHNob3VsZCBzZXQgaXQgYmFjayB0byB0aGUgVUkgcHJvY2VzcyBidW5kbGUg aWRlbnRpZmllci4gVGhpcyBpcworICAgICAgICBtb3JlIGFsaWduZWQgd2l0aCByZXNldGluZyBz dGF0ZSB0byBleHBlY3RlZCBiZWhhdmlvci4KKworICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL05l dHdvcmtQcm9jZXNzLmNwcDoKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Byb2Nlc3M6OnJlc2V0 QnVuZGxlSWRlbnRpZmllclRlc3RpbmcpOgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vz czo6Y2xlYXJCdW5kbGVJZGVudGlmaWVyKTogRGVsZXRlZC4KKyAgICAgICAgKiBOZXR3b3JrUHJv Y2Vzcy9OZXR3b3JrUHJvY2Vzcy5oOgorICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL05ldHdvcmtQ cm9jZXNzLm1lc3NhZ2VzLmluOgorICAgICAgICAqIFVJUHJvY2Vzcy9OZXR3b3JrL05ldHdvcmtQ cm9jZXNzUHJveHkuY3BwOgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzc1Byb3h5Ojpj bGVhckJ1bmRsZUlkZW50aWZpZXIpOgorCiAyMDIwLTA2LTAxICBTYW0gV2VpbmlnICA8d2Vpbmln QGFwcGxlLmNvbT4KIAogICAgICAgICBFeHRlbmRlZCBDb2xvcjogUmVwbGFjZSBDb2xvciBjb25z dHJ1Y3RvcnMgdGFraW5nIG51bWVyaWMgdmFsdWVzIHdpdGggdHlwZSBzcGVjaWZpYyBmYWN0b3J5 IGZ1bmN0aW9ucwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9OZXR3 b3JrUHJvY2Vzcy5jcHAgYi9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9j ZXNzLmNwcAppbmRleCA3Y2EzNjc2YmE3MWE2N2E0MWRiZjIxZWQ3OTQ0ZjEyYTcyN2M0NDYyLi4x MWQzMTc1MDdhNzE1YzU4MTE4ZDhlMzg0YTY5NzM5MzgxNDE3NGIyIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcApAQCAtMjc2MywxMCArMjc2 MywxMSBAQCB2b2lkIE5ldHdvcmtQcm9jZXNzOjp1cGRhdGVCdW5kbGVJZGVudGlmaWVyKFN0cmlu ZyYmIGJ1bmRsZUlkZW50aWZpZXIsIENvbXBsZXRpbwogICAgIGNvbXBsZXRpb25IYW5kbGVyKCk7 CiB9CiAKLXZvaWQgTmV0d29ya1Byb2Nlc3M6OmNsZWFyQnVuZGxlSWRlbnRpZmllcihDb21wbGV0 aW9uSGFuZGxlcjx2b2lkKCk+JiYgY29tcGxldGlvbkhhbmRsZXIpCit2b2lkIE5ldHdvcmtQcm9j ZXNzOjpyZXNldEJ1bmRsZUlkZW50aWZpZXJUZXN0aW5nKFN0cmluZyYmIGRlZmF1bHRCdW5kbGVJ ZGVudGlmaWVyLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKCk+JiYgY29tcGxldGlvbkhhbmRsZXIp CiB7CiAjaWYgUExBVEZPUk0oQ09DT0EpCiAgICAgV2ViQ29yZTo6Y2xlYXJBcHBsaWNhdGlvbkJ1 bmRsZUlkZW50aWZpZXJUZXN0aW5nT3ZlcnJpZGUoKTsKKyAgICBXZWJDb3JlOjpzZXRBcHBsaWNh dGlvbkJ1bmRsZUlkZW50aWZpZXIoZGVmYXVsdEJ1bmRsZUlkZW50aWZpZXIpOwogI2VuZGlmCiAg ICAgY29tcGxldGlvbkhhbmRsZXIoKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvTmV0 d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaCBiL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nl c3MvTmV0d29ya1Byb2Nlc3MuaAppbmRleCBlNmJmMjQ1M2NkZjliYzBmYWEyOTdjZWYzMzI5MDcy ZjY0NmFiN2Y5Li40NzYwYjBjNDFiNzc0ZTNhNjUzNTc5NzNmOTFhNTNlMjVlMTQ5ZjA0IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmgKKysr IGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5oCkBAIC0zNTYs NyArMzU2LDcgQEAgcHVibGljOgogCiAgICAgdm9pZCBicm9hZGNhc3RDb25zb2xlTWVzc2FnZShQ QUw6OlNlc3Npb25JRCwgSlNDOjpNZXNzYWdlU291cmNlLCBKU0M6Ok1lc3NhZ2VMZXZlbCwgY29u c3QgU3RyaW5nJiBtZXNzYWdlKTsKICAgICB2b2lkIHVwZGF0ZUJ1bmRsZUlkZW50aWZpZXIoU3Ry aW5nJiYsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoKT4mJik7Ci0gICAgdm9pZCBjbGVhckJ1bmRs ZUlkZW50aWZpZXIoQ29tcGxldGlvbkhhbmRsZXI8dm9pZCgpPiYmKTsKKyAgICB2b2lkIHJlc2V0 QnVuZGxlSWRlbnRpZmllclRlc3RpbmcoU3RyaW5nJiYsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQo KT4mJik7CiAKIHByaXZhdGU6CiAgICAgdm9pZCBwbGF0Zm9ybUluaXRpYWxpemVOZXR3b3JrUHJv Y2Vzcyhjb25zdCBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycyYpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5tZXNzYWdlcy5p biBiL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MubWVzc2FnZXMu aW4KaW5kZXggNDBjMmQ4YzZkNTNmZTUwODQxNmJmNDUxOGQ1NWRjMzQ5YmRiN2JlMS4uZTNjMGMy ZjdlMGFhMjAwMWQxNmQ1YzI3MTgzODhjNWQzNDJhMWFmMiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5tZXNzYWdlcy5pbgorKysgYi9Tb3Vy Y2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLm1lc3NhZ2VzLmluCkBAIC0x ODUsNSArMTg1LDUgQEAgbWVzc2FnZXMgLT4gTmV0d29ya1Byb2Nlc3MgTGVnYWN5UmVjZWl2ZXIg ewogICAgIENsZWFyU2VydmljZVdvcmtlckVudGl0bGVtZW50T3ZlcnJpZGUoKSAtPiAoKSBBc3lu YwogI2VuZGlmCiAgICAgVXBkYXRlQnVuZGxlSWRlbnRpZmllcihTdHJpbmcgYnVuZGxlSWRlbnRp ZmllcikgLT4gKCkgQXN5bmMKLSAgICBDbGVhckJ1bmRsZUlkZW50aWZpZXIoKSAtPiAoKSBBc3lu YworICAgIFJlc2V0QnVuZGxlSWRlbnRpZmllclRlc3RpbmcoU3RyaW5nIGRlZmF1bHRCdW5kbGVJ ZGVudGlmaWVyKSAtPiAoKSBBc3luYwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvTmV0d29yay9OZXR3b3JrUHJvY2Vzc1Byb3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL05ldHdvcmsvTmV0d29ya1Byb2Nlc3NQcm94eS5jcHAKaW5kZXggYTllNGZlZTQ5NWU1 MzQ5NjU5YjVkOTU1NjhlMWI5N2NjZWY0YTU3ZS4uYzQ5YTU4ZTFiN2QyYjVmMjFjZTU3MTIzZjll ZGEzZDFlNDYyNGJhNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvTmV0d29y ay9OZXR3b3JrUHJvY2Vzc1Byb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9O ZXR3b3JrL05ldHdvcmtQcm9jZXNzUHJveHkuY3BwCkBAIC02MCw2ICs2MCw3IEBACiAjaW5jbHVk ZSAiV2Vic2l0ZURhdGFTdG9yZUNsaWVudC5oIgogI2luY2x1ZGUgPFdlYkNvcmUvQ2xpZW50T3Jp Z2luLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9SZWdpc3RyYWJsZURvbWFpbi5oPgorI2luY2x1ZGUg PFdlYkNvcmUvUnVudGltZUFwcGxpY2F0aW9uQ2hlY2tzLmg+CiAjaW5jbHVkZSA8d3RmL0NvbXBs ZXRpb25IYW5kbGVyLmg+CiAKICNpZiBFTkFCTEUoU0VDX0lURU1fU0hJTSkKQEAgLTE1NDQsNyAr MTU0NSw4IEBAIHZvaWQgTmV0d29ya1Byb2Nlc3NQcm94eTo6dXBkYXRlQnVuZGxlSWRlbnRpZmll cihjb25zdCBTdHJpbmcmIGJ1bmRsZUlkZW50aWZpZXIsCiAKIHZvaWQgTmV0d29ya1Byb2Nlc3NQ cm94eTo6Y2xlYXJCdW5kbGVJZGVudGlmaWVyKENvbXBsZXRpb25IYW5kbGVyPHZvaWQoKT4mJiBj b21wbGV0aW9uSGFuZGxlcikKIHsKLSAgICBzZW5kV2l0aEFzeW5jUmVwbHkoTWVzc2FnZXM6Ok5l dHdvcmtQcm9jZXNzOjpDbGVhckJ1bmRsZUlkZW50aWZpZXIoKSwgV1RGTW92ZShjb21wbGV0aW9u SGFuZGxlcikpOworICAgIGF1dG8gZGVmYXVsdEJ1bmRsZUlkZW50aWZpZXIgPSBXZWJDb3JlOjph cHBsaWNhdGlvbkJ1bmRsZUlkZW50aWZpZXIoKTsKKyAgICBzZW5kV2l0aEFzeW5jUmVwbHkoTWVz c2FnZXM6Ok5ldHdvcmtQcm9jZXNzOjpSZXNldEJ1bmRsZUlkZW50aWZpZXJUZXN0aW5nKGRlZmF1 bHRCdW5kbGVJZGVudGlmaWVyKSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOwogfQogCiB9 IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xz L0NoYW5nZUxvZwppbmRleCBiNmFjMTlhZTg4ZDg5NzYzODI0OTQ1YTJjNDk0MGU5ZTg4ZDA1MTU3 Li4yOGZlOTJmMjRkNWUwMjI3NWMwYTZhMWRjYzRkYjU2MmFjMzZhNDc4IDEwMDY0NAotLS0gYS9U b29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIw MjAtMDYtMDQgIEthdGUgQ2hlbmV5ICA8a2F0aGVyaW5lX2NoZW5leUBhcHBsZS5jb20+CisKKyAg ICAgICAgUkVHUkVTU0lPTiAocjI2MjIxMik6IFsgaU9TIERlYnVnIHdrMiBdIEFTU0VSVElPTiBG QUlMRUQ6ICFpc1N5bmNocm9ub3VzKCkgfHwgIW1fc3luY2hyb25vdXNMb2FkRGF0YS0+ZGVsYXll ZFJlcGx5IGluIFdlYktpdDo6TmV0d29ya1Jlc291cmNlTG9hZGVyCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTI2NzgKKyAgICAgICAgPHJkYXI6Ly9w cm9ibGVtLzYzNzk3NzU4PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogV2ViS2l0VGVzdFJ1bm5lci9UZXN0Q29udHJvbGxlci5jcHA6CisgICAgICAg IChXVFI6OlRlc3RDb250cm9sbGVyOjpjcmVhdGVXZWJWaWV3V2l0aE9wdGlvbnMpOgorICAgICAg ICBNYWtlIHN1cmUgd2UgY2xlYXIgdGhlIGJ1bmRsZSBpZGVudGlmaWVyIGJlZm9yZSBzZXR0aW5n IGEgbmV3IG9uZSB0bworICAgICAgICBhdm9pZCBoaXR0aW5nIHRoZSBhc3NlcnRpb24gaW4gUnVu dGltZUFwcGxpY2F0aW9uQ2hlY2tzLgorCisgICAgICAgIChXVFI6OlRlc3RDb250cm9sbGVyOjpl bnN1cmVWaWV3U3VwcG9ydHNPcHRpb25zRm9yVGVzdCk6CisgICAgICAgIFdlIHNob3VsZCBub3Qg cmV1c2UgYSB3ZWJ2aWV3IGlmIHRoZSBidW5kbGUgaWRlbnRpZmllciBpcyBzZXQuIFRlc3RzCisg ICAgICAgIHRoYXQgc2V0IHRoZSBidW5kbGUgaWRlbnRpZmllciByZXF1aXJlIGEgd2VidmlldyB3 aXRoIHNwZWNpZmljIG9wdGlvbnMuCisKIDIwMjAtMDYtMDEgIENhcmxvcyBBbGJlcnRvIExvcGV6 IFBlcmV6ICA8Y2xvcGV6QGlnYWxpYS5jb20+CiAKICAgICAgICAgW0VXU10gQWRkIGEgc3BlY2lh bCBjYXNlIGZvciBydW5uaW5nIHRoZSBsYXlvdXQgdGVzdCBzdGVwIHdpdGhvdXQgYWJvcnRpbmcg aW4gY2FzZSBvZiBtYW55IGZhaWx1cmVzIGZvciBXUFQgdGVzdHMKZGlmZiAtLWdpdCBhL1Rvb2xz L1dlYktpdFRlc3RSdW5uZXIvVGVzdENvbnRyb2xsZXIuY3BwIGIvVG9vbHMvV2ViS2l0VGVzdFJ1 bm5lci9UZXN0Q29udHJvbGxlci5jcHAKaW5kZXggZTY2OTczYjc0NWRlZThiYWNmNzE3Y2Q4MjZj YmE4N2NiZmE4ZjQ5OS4uNzAzNWFhYjBhZDFhZmE5MDk1OWUzODExNGFkODYyNGI5ZWRiMGJmMiAx MDA2NDQKLS0tIGEvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9UZXN0Q29udHJvbGxlci5jcHAKKysr IGIvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9UZXN0Q29udHJvbGxlci5jcHAKQEAgLTY0Myw2ICs2 NDMsNyBAQCB2b2lkIFRlc3RDb250cm9sbGVyOjpjcmVhdGVXZWJWaWV3V2l0aE9wdGlvbnMoY29u c3QgVGVzdE9wdGlvbnMmIG9wdGlvbnMpCiAgICAgaWYgKCFvcHRpb25zLmFwcGxpY2F0aW9uQnVu ZGxlSWRlbnRpZmllci5pc0VtcHR5KCkpIHsKICAgICAgICAgLy8gVGhlIGJ1bmRsZSBpZGVudGlm aWVyIGNhbiBvbmx5IGJlIHNldCBvbmNlIHBlciB0ZXN0LCBhbmQgaXMgY2xlYXJlZCBiZXR3ZWVu IHRlc3RzLgogICAgICAgICBSRUxFQVNFX0FTU0VSVCghbV9oYXNTZXRBcHBsaWNhdGlvbkJ1bmRs ZUlkZW50aWZpZXIpOworICAgICAgICBjbGVhckFwcGxpY2F0aW9uQnVuZGxlSWRlbnRpZmllclRl c3RpbmdPdmVycmlkZSgpOwogICAgICAgICBzZXRBcHBsaWNhdGlvbkJ1bmRsZUlkZW50aWZpZXIo b3B0aW9ucy5hcHBsaWNhdGlvbkJ1bmRsZUlkZW50aWZpZXIpOwogICAgICAgICBtX2hhc1NldEFw cGxpY2F0aW9uQnVuZGxlSWRlbnRpZmllciA9IHRydWU7CiAgICAgfQpAQCAtODA4LDcgKzgwOSw3 IEBAIHZvaWQgVGVzdENvbnRyb2xsZXI6OmVuc3VyZVZpZXdTdXBwb3J0c09wdGlvbnNGb3JUZXN0 KGNvbnN0IFRlc3RJbnZvY2F0aW9uJiB0ZXN0CiAgICAgaWYgKG1fbWFpbldlYlZpZXcpIHsKICAg ICAgICAgLy8gSGF2aW5nIGNyZWF0ZWQgYW5vdGhlciBwYWdlICh2aWEgd2luZG93Lm9wZW4oKSkg cHJldmVudHMgcHJvY2VzcyBzd2FwcGluZyBvbiBuYXZpZ2F0aW9uIGFuZCBpdCBtYXkgdGhlcmVm b3JlCiAgICAgICAgIC8vIGNhdXNlIGZsYWtpbmVzcyB0byByZXVzZSB0aGUgdmlldy4KLSAgICAg ICAgaWYgKCFtX2NyZWF0ZWRPdGhlclBhZ2UgJiYgbV9tYWluV2ViVmlldy0+dmlld1N1cHBvcnRz T3B0aW9ucyhvcHRpb25zKSkKKyAgICAgICAgaWYgKCFtX2NyZWF0ZWRPdGhlclBhZ2UgJiYgbV9t YWluV2ViVmlldy0+dmlld1N1cHBvcnRzT3B0aW9ucyhvcHRpb25zKSAmJiBvcHRpb25zLmFwcGxp Y2F0aW9uQnVuZGxlSWRlbnRpZmllci5pc0VtcHR5KCkpCiAgICAgICAgICAgICByZXR1cm47CiAK ICAgICAgICAgd2lsbERlc3Ryb3lXZWJWaWV3KCk7Cg== 401072 2020-06-04 13:24:52 -0700 2020-06-04 15:50:14 -0700 Patch bug-212678-20200604132451.patch text/plain 5738 katherine_cheney U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyMzc5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2RkZDFlNjYyM2Y4MWU2 MTk4YmZmODJhNTdhMzRhNTViYjE5MzAzOS4uOTVjMWMyYjgzNWExN2FiOGU0ZGQ4MGZlMDk4N2Uw ZTZjNzNlZmMzYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDIwLTA2LTA0ICBLYXRl IENoZW5leSAgPGthdGhlcmluZV9jaGVuZXlAYXBwbGUuY29tPgorCisgICAgICAgIFJFR1JFU1NJ T04gKHIyNjIyMTIpOiBbIGlPUyBEZWJ1ZyB3azIgXSBBU1NFUlRJT04gRkFJTEVEOiAhaXNTeW5j aHJvbm91cygpIHx8ICFtX3N5bmNocm9ub3VzTG9hZERhdGEtPmRlbGF5ZWRSZXBseSBpbiBXZWJL aXQ6Ok5ldHdvcmtSZXNvdXJjZUxvYWRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjEyNjc4CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS82Mzc5Nzc1 OD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBObyBu ZXcgdGVzdHMsIHRoaXMgd2lsbCBmaXggaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9hY2Nlc3Mt Y29udHJvbC1wcmVmbGlnaHQtY3JlZGVudGlhbC1zeW5jLmh0bWwuCisKKyAgICAgICAgUmVmYWN0 b3IgdGhlIGJ1bmRsZSBpZGVudGlmaWVyIHNldHRlcnMgYW5kIGdldHRlcnMgaW4KKyAgICAgICAg UnVudGltZUFwcGxpY2F0aW9uQ2hlY2tzQ29jb2EubW0gc28gdGhhdCBhIHNlcGFyYXRlIGZ1bmN0 aW9uIHNldHMKKyAgICAgICAgYW4gb3ZlcnJpZGUgYnVuZGxlIGlkZW50aWZpZXIsIGFuZCBjbGVh cmluZyB0aGUgb3ZlcnJpZGUgaWRlbnRpZmllcgorICAgICAgICBkb2VzIG5vdCBjbGVhciB0aGUg VUkgcHJvY2VzcyBidW5kbGUgaWRlbnRpZmllciBhcyB3ZWxsLiAKKworICAgICAgICAqIHBsYXRm b3JtL1J1bnRpbWVBcHBsaWNhdGlvbkNoZWNrcy5oOgorICAgICAgICAqIHBsYXRmb3JtL2NvY29h L1J1bnRpbWVBcHBsaWNhdGlvbkNoZWNrc0NvY29hLm1tOgorICAgICAgICAoV2ViQ29yZTo6YnVu ZGxlSWRlbnRpZmllck92ZXJyaWRlKToKKyAgICAgICAgKFdlYkNvcmU6OmJ1bmRsZUlkZW50aWZp ZXIpOgorICAgICAgICAoV2ViQ29yZTo6YXBwbGljYXRpb25CdW5kbGVJZGVudGlmaWVyKToKKyAg ICAgICAgKFdlYkNvcmU6OnNldEFwcGxpY2F0aW9uQnVuZGxlSWRlbnRpZmllcik6CisgICAgICAg IChXZWJDb3JlOjpzZXRBcHBsaWNhdGlvbkJ1bmRsZUlkZW50aWZpZXJPdmVycmlkZSk6CisgICAg ICAgIChXZWJDb3JlOjpjbGVhckFwcGxpY2F0aW9uQnVuZGxlSWRlbnRpZmllclRlc3RpbmdPdmVy cmlkZSk6CisgICAgICAgIChXZWJDb3JlOjphcHBsaWNhdGlvbkJ1bmRsZUlkZW50aWZpZXJPdmVy cmlkZSk6IERlbGV0ZWQuCisKIDIwMjAtMDUtMjUgIFNlcmdpbyBWaWxsYXIgU2VuaW4gIDxzdmls bGFyQGlnYWxpYS5jb20+CiAKICAgICAgICAgW2Nzcy1mbGV4Ym94XSBUYWJsZXMgYXMgZmxleCBp dGVtcyBzaG91bGQgb2JleSB0aGUgZmxleCBjb250YWluZXIgc2l6aW5nCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9SdW50aW1lQXBwbGljYXRpb25DaGVja3MuaCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL1J1bnRpbWVBcHBsaWNhdGlvbkNoZWNrcy5oCmluZGV4IDBjZjQy ZDZiMzNiMDM1MjA4OTQwYmY4MWY0MjBmNWY4Nzc4NTExYjMuLjMzZjFkMGJmNTM3YjZmMDQ5NDY5 Nzk5NWYzNzllM2E5N2RkZDE0OGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L1J1bnRpbWVBcHBsaWNhdGlvbkNoZWNrcy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L1J1bnRpbWVBcHBsaWNhdGlvbkNoZWNrcy5oCkBAIC00NCw2ICs0NCw3IEBAIGJvb2wgaXNJbldl YlByb2Nlc3MoKTsKIGJvb2wgaXNJbk5ldHdvcmtQcm9jZXNzKCk7CiAKIFdFQkNPUkVfRVhQT1JU IHZvaWQgc2V0QXBwbGljYXRpb25CdW5kbGVJZGVudGlmaWVyKGNvbnN0IFN0cmluZyYpOworV0VC Q09SRV9FWFBPUlQgdm9pZCBzZXRBcHBsaWNhdGlvbkJ1bmRsZUlkZW50aWZpZXJPdmVycmlkZShj b25zdCBTdHJpbmcmKTsKIFdFQkNPUkVfRVhQT1JUIFN0cmluZyBhcHBsaWNhdGlvbkJ1bmRsZUlk ZW50aWZpZXIoKTsKIFdFQkNPUkVfRVhQT1JUIHZvaWQgY2xlYXJBcHBsaWNhdGlvbkJ1bmRsZUlk ZW50aWZpZXJUZXN0aW5nT3ZlcnJpZGUoKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vY29jb2EvUnVudGltZUFwcGxpY2F0aW9uQ2hlY2tzQ29jb2EubW0gYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9jb2NvYS9SdW50aW1lQXBwbGljYXRpb25DaGVja3NDb2NvYS5tbQpp bmRleCA1ZGJkMGM3M2Y2Yjk2MmIwMWVmNDgzYzkzYjZlNDM0OWNmMzkyYTIxLi43YjdmMTgzNjc4 YTEwZjg1Y2NhZGRhNWZiNmY5OGJkMzA2OTY0OGU3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9jb2NvYS9SdW50aW1lQXBwbGljYXRpb25DaGVja3NDb2NvYS5tbQorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jb2NvYS9SdW50aW1lQXBwbGljYXRpb25DaGVja3NDb2Nv YS5tbQpAQCAtNDIsMzQgKzQyLDQ5IEBAIHN0YXRpYyBib29sIGFwcGxpY2F0aW9uQnVuZGxlSWRl bnRpZmllck92ZXJyaWRlV2FzUXVlcmllZDsKIAogLy8gVGhlIGFwcGxpY2F0aW9uIGJ1bmRsZSBp ZGVudGlmaWVyIGdldHMgc2V0IHRvIHRoZSBVSVByb2Nlc3MgYnVuZGxlIGlkZW50aWZpZXIgYnkg dGhlIFdlYlByb2Nlc3MgYW5kCiAvLyB0aGUgTmV0d29ya2luZyB1cG9uIGluaXRpYWxpemF0aW9u LiBJdCBpcyB1bnNldCBvdGhlcndpc2UuCi1zdGF0aWMgU3RyaW5nJiBhcHBsaWNhdGlvbkJ1bmRs ZUlkZW50aWZpZXJPdmVycmlkZSgpCitzdGF0aWMgU3RyaW5nJiBidW5kbGVJZGVudGlmaWVyT3Zl cnJpZGUoKQogewotICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxTdHJpbmc+IGlkZW50aWZpZXI7 CisgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPFN0cmluZz4gaWRlbnRpZmllck92ZXJyaWRlOwog I2lmICFBU1NFUlRfTVNHX0RJU0FCTEVECiAgICAgYXBwbGljYXRpb25CdW5kbGVJZGVudGlmaWVy T3ZlcnJpZGVXYXNRdWVyaWVkID0gdHJ1ZTsKICNlbmRpZgorICAgIHJldHVybiBpZGVudGlmaWVy T3ZlcnJpZGU7Cit9CisKK3N0YXRpYyBTdHJpbmcmIGJ1bmRsZUlkZW50aWZpZXIoKQoreworICAg IHN0YXRpYyBOZXZlckRlc3Ryb3llZDxTdHJpbmc+IGlkZW50aWZpZXI7CiAgICAgcmV0dXJuIGlk ZW50aWZpZXI7CiB9CiAKIFN0cmluZyBhcHBsaWNhdGlvbkJ1bmRsZUlkZW50aWZpZXIoKQogewot ICAgIC8vIFRoZSBvdmVycmlkZSBvbmx5IGdldHMgc2V0IGluIFdlYktpdDIncyBXZWJQcm9jZXNz IGFuZCBOZXR3b3JrUHJvY2Vzcy4gSWYgdW5zZXQsIHdlIHVzZSB0aGUgbWFpbiBidW5kbGUgaWRl bnRpZmllci4KLSAgICBjb25zdCBhdXRvJiBpZGVudGlmaWVyID0gYXBwbGljYXRpb25CdW5kbGVJ ZGVudGlmaWVyT3ZlcnJpZGUoKTsKKyAgICAvLyBUaGUgb3ZlcnJpZGUgb25seSBnZXRzIHNldCBp biBXZWJLaXRUZXN0UnVubmVyLiBJZiB1bnNldCwgd2UgdXNlIHRoZSBidW5kbGUgaWRlbnRpZmll ciBzZXQKKyAgICAvLyBpbiBXZWJLaXQyJ3MgV2ViUHJvY2VzcyBhbmQgTmV0d29ya1Byb2Nlc3Mu IElmIHRoYXQgaXMgYWxzbyB1bnNldCwgd2UgdXNlIHRoZSBtYWluIGJ1bmRsZSBpZGVudGlmaWVy LgorICAgIGF1dG8gaWRlbnRpZmllciA9IGJ1bmRsZUlkZW50aWZpZXJPdmVycmlkZSgpOwogICAg IEFTU0VSVChpZGVudGlmaWVyLmlzTnVsbCgpIHx8IFJ1bkxvb3A6OmlzTWFpbigpKTsKKyAgICBp ZiAoaWRlbnRpZmllci5pc051bGwoKSkKKyAgICAgICAgaWRlbnRpZmllciA9IGJ1bmRsZUlkZW50 aWZpZXIoKTsKICAgICByZXR1cm4gaWRlbnRpZmllci5pc051bGwoKSA/IFN0cmluZyhbW05TQnVu ZGxlIG1haW5CdW5kbGVdIGJ1bmRsZUlkZW50aWZpZXJdKSA6IGlkZW50aWZpZXI7CiB9CiAKLXZv aWQgc2V0QXBwbGljYXRpb25CdW5kbGVJZGVudGlmaWVyKGNvbnN0IFN0cmluZyYgYnVuZGxlSWRl bnRpZmllcikKK3ZvaWQgc2V0QXBwbGljYXRpb25CdW5kbGVJZGVudGlmaWVyKGNvbnN0IFN0cmlu ZyYgaWRlbnRpZmllcikKK3sKKyAgICBBU1NFUlQoUnVuTG9vcDo6aXNNYWluKCkpOworICAgIGJ1 bmRsZUlkZW50aWZpZXIoKSA9IGlkZW50aWZpZXI7Cit9CisKK3ZvaWQgc2V0QXBwbGljYXRpb25C dW5kbGVJZGVudGlmaWVyT3ZlcnJpZGUoY29uc3QgU3RyaW5nJiBpZGVudGlmaWVyKQogewogICAg IEFTU0VSVChSdW5Mb29wOjppc01haW4oKSk7CiAgICAgQVNTRVJUX1dJVEhfTUVTU0FHRSghYXBw bGljYXRpb25CdW5kbGVJZGVudGlmaWVyT3ZlcnJpZGVXYXNRdWVyaWVkLCAiYXBwbGljYXRpb25C dW5kbGVJc0VxdWFsVG8oKSBhbmQgYXBwbGljYXRpb25CdW5kbGVTdGFydHNXaXRoKCkgc2hvdWxk IG5vdCBiZSBjYWxsZWQgYmVmb3JlIHNldEFwcGxpY2F0aW9uQnVuZGxlSWRlbnRpZmllcigpIik7 Ci0gICAgYXBwbGljYXRpb25CdW5kbGVJZGVudGlmaWVyT3ZlcnJpZGUoKSA9IGJ1bmRsZUlkZW50 aWZpZXI7CisgICAgYnVuZGxlSWRlbnRpZmllck92ZXJyaWRlKCkgPSBpZGVudGlmaWVyOwogfQog CiB2b2lkIGNsZWFyQXBwbGljYXRpb25CdW5kbGVJZGVudGlmaWVyVGVzdGluZ092ZXJyaWRlKCkK IHsKICAgICBBU1NFUlQoUnVuTG9vcDo6aXNNYWluKCkpOwotICAgIGFwcGxpY2F0aW9uQnVuZGxl SWRlbnRpZmllck92ZXJyaWRlKCkgPSBTdHJpbmcoKTsKKyAgICBidW5kbGVJZGVudGlmaWVyT3Zl cnJpZGUoKSA9IFN0cmluZygpOwogI2lmICFBU1NFUlRfTVNHX0RJU0FCTEVECiAgICAgYXBwbGlj YXRpb25CdW5kbGVJZGVudGlmaWVyT3ZlcnJpZGVXYXNRdWVyaWVkID0gZmFsc2U7CiAjZW5kaWYK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdU ZXN0aW5nLm1tIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlld1Rl c3RpbmcubW0KaW5kZXggYTcxNWUyM2Q5ZTRhNDM0MGNiMzk2YmZmMjNmN2EzYTU4YzRmODQ5NS4u YzRlNTc0YmI1ZDIwOTIyYmQ3Y2QzZTQ0MjQ3M2RmMjA0NjNkOWZjZCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlld1Rlc3RpbmcubW0KKysrIGIv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlld1Rlc3RpbmcubW0KQEAg LTIyMyw3ICsyMjMsNyBAQCAtICh2b2lkKV9kb0FmdGVyUHJvY2Vzc2luZ0FsbFBlbmRpbmdNb3Vz ZUV2ZW50czooZGlzcGF0Y2hfYmxvY2tfdClhY3Rpb24KIAogKyAodm9pZClfc2V0QXBwbGljYXRp b25CdW5kbGVJZGVudGlmaWVyOihOU1N0cmluZyAqKWJ1bmRsZUlkZW50aWZpZXIKIHsKLSAgICBX ZWJDb3JlOjpzZXRBcHBsaWNhdGlvbkJ1bmRsZUlkZW50aWZpZXIoU3RyaW5nKGJ1bmRsZUlkZW50 aWZpZXIpKTsKKyAgICBXZWJDb3JlOjpzZXRBcHBsaWNhdGlvbkJ1bmRsZUlkZW50aWZpZXJPdmVy cmlkZShTdHJpbmcoYnVuZGxlSWRlbnRpZmllcikpOwogfQogCiArICh2b2lkKV9jbGVhckFwcGxp Y2F0aW9uQnVuZGxlSWRlbnRpZmllclRlc3RpbmdPdmVycmlkZQo=