177389 2017-09-22 15:07:18 -0700 WeakPtrFactory should allow downcasting 2017-10-16 12:32:35 -0700 1 1 1 Unclassified WebKit DOM WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 177375 177429 1 jiewen_tan zalan benjamin buildbot cdumez cmarcelo commit-queue dbates ggaren jiewen_tan rniwa webkit-bug-importer zalan oldest_to_newest 1351836 0 jiewen_tan 2017-09-22 15:07:18 -0700 WeakPtrFactory should allow downcasting, i.e. creating a weak pointer of the current class' derived classes. 1351838 1 webkit-bug-importer 2017-09-22 15:09:48 -0700 <rdar://problem/34604174> 1351842 2 jiewen_tan 2017-09-22 15:15:47 -0700 Geoff's proposal: The Problem we have currently: WeakPtr<Element> ptr = parent.createWeakPtr(); // fails: returns WeakPtr<Node> WeakPtr<Element> ptr = parent.createWeakPtr<Element>(); // succeeds: returns WeakPtr<Element> Solution is something like this: template<typename U> WeakPtr<U> createWeakPtr() const { return WeakPtr<U>(static_reference_cast<U>(m_ref); } 1352462 3 321758 zalan 2017-09-25 15:26:44 -0700 Created attachment 321758 Patch 1352523 4 321758 jiewen_tan 2017-09-25 17:22:23 -0700 Comment on attachment 321758 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=321758&action=review Thank you for making this patch. Have one question listed below. Could you explain it to me? > Source/WTF/wtf/WeakPtr.h:108 > + return WeakPtr<U>(Ref<WeakReference<U>>(static_cast<WeakReference<U>&>(*m_ref))); No sure why static_cast works here. Could you elaborate it a little bit? 1352524 5 ggaren 2017-09-25 17:27:28 -0700 > > Source/WTF/wtf/WeakPtr.h:108 > > + return WeakPtr<U>(Ref<WeakReference<U>>(static_cast<WeakReference<U>&>(*m_ref))); > > No sure why static_cast works here. Could you elaborate it a little bit? Yeah, I didn't write it quite right here. I think Zalan has a working copy of this function now. 1352530 6 ggaren 2017-09-25 17:43:14 -0700 > > Source/WTF/wtf/WeakPtr.h:108 > > + return WeakPtr<U>(Ref<WeakReference<U>>(static_cast<WeakReference<U>&>(*m_ref))); > > No sure why static_cast works here. Could you elaborate it a little bit? Yeah, actually, this is wrong. It only worked in this patch because T and U are equal across all invocations. But when T and U are not equal, static casting WeakReference<T>& to WeakReference<U>& is an error. So, we need a better version of this function. 1352531 7 zalan 2017-09-25 17:45:37 -0700 (In reply to Geoffrey Garen from comment #6) > > > Source/WTF/wtf/WeakPtr.h:108 > > > + return WeakPtr<U>(Ref<WeakReference<U>>(static_cast<WeakReference<U>&>(*m_ref))); > > > > No sure why static_cast works here. Could you elaborate it a little bit? > > Yeah, actually, this is wrong. It only worked in this patch because T and U > are equal across all invocations. But when T and U are not equal, static > casting WeakReference<T>& to WeakReference<U>& is an error. > > So, we need a better version of this function. Yea, and I was going to work on that. This was more of the first iteration, hence not landed yet. 1352534 8 ggaren 2017-09-25 17:50:53 -0700 I guess there are two ways to fix this: We could add a reinterpret_cast that static_asserts the conversion between T* and U* is OK. Or we could add a template parameter to WeakPtr, and say that WeakPtr points to WeakReference<T>, and casts to U* when you get its contents. The second option is probably more in line with idiomatic C++, so if it doesn't make WeakPtr construction too annoying, it might be preferred. 1353035 9 321940 jiewen_tan 2017-09-26 23:54:54 -0700 Created attachment 321940 Patch 1353036 10 buildbot 2017-09-26 23:55:59 -0700 Attachment 321940 did not pass style-queue: ERROR: Source/WTF/wtf/WeakPtr.h:68: Should be indented on a separate line, with the colon or comma first on that line. [whitespace/indent] [4] ERROR: Source/WTF/wtf/WeakPtr.h:69: Should be indented on a separate line, with the colon or comma first on that line. [whitespace/indent] [4] Total errors found: 2 in 5 files If any of these errors are false positives, please file a bug against check-webkit-style. 1353037 11 321940 jiewen_tan 2017-09-27 00:00:10 -0700 Comment on attachment 321940 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=321940&action=review > Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp:215 > + WeakPtr<Derived, Base> derivedWeakPtr; Ryosuke and I are kind of worrying this format will be annoying to use. However, I don't know how it could be prevented, i.e. using WeakPtr<Derived> instead of WeakPtr<Derived, Base>. If anyone has any ideas, please tell me. Appreciate it. 1353111 12 321940 ggaren 2017-09-27 08:13:01 -0700 Comment on attachment 321940 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=321940&action=review > Source/WTF/wtf/WeakPtr.h:88 > + static_assert((!std::is_class<U>::value && !std::is_class<T>::value) || std::is_base_of<U, T>::value, "U should be a base class of T"); There's no need for this assertion because it's built into the static_cast. The value of the double template parameter solution is that you don't need any assertions: The language guarantees correctness. 1353112 13 321940 ggaren 2017-09-27 08:26:06 -0700 Comment on attachment 321940 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=321940&action=review >> Source/WTF/wtf/WeakPtr.h:88 >> + static_assert((!std::is_class<U>::value && !std::is_class<T>::value) || std::is_base_of<U, T>::value, "U should be a base class of T"); > > There's no need for this assertion because it's built into the static_cast. The value of the double template parameter solution is that you don't need any assertions: The language guarantees correctness. ...built into the static_cast in the getter. >> Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp:215 >> + WeakPtr<Derived, Base> derivedWeakPtr; > > Ryosuke and I are kind of worrying this format will be annoying to use. However, I don't know how it could be prevented, i.e. using WeakPtr<Derived> instead of WeakPtr<Derived, Base>. If anyone has any ideas, please tell me. Appreciate it. If this is too annoying, we can use the reinterpret_cast solution: template<typename T, typename U> WeakReference<T>& static_weak_reference_cast(WeakReference<U>& weakReference) { static_assert(std::is_convertible<T*, U*>::value, "U* must be convertible to T*"); return reinterpret_cast<WeakReference <T>&>(weakReference); } Then createWeakPtr would static_weak_reference_cast m_ref when creating a WeakPtr. 1353187 14 321940 jiewen_tan 2017-09-27 11:14:43 -0700 Comment on attachment 321940 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=321940&action=review Thanks Geoff for reviewing the patch. I will upload a patch addressing comments in this patch and then upload another that uses the first solution. Then we can decide which one to go. >>> Source/WTF/wtf/WeakPtr.h:88 >>> + static_assert((!std::is_class<U>::value && !std::is_class<T>::value) || std::is_base_of<U, T>::value, "U should be a base class of T"); >> >> There's no need for this assertion because it's built into the static_cast. The value of the double template parameter solution is that you don't need any assertions: The language guarantees correctness. > > ...built into the static_cast in the getter. Removed. >>> Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp:215 >>> + WeakPtr<Derived, Base> derivedWeakPtr; >> >> Ryosuke and I are kind of worrying this format will be annoying to use. However, I don't know how it could be prevented, i.e. using WeakPtr<Derived> instead of WeakPtr<Derived, Base>. If anyone has any ideas, please tell me. Appreciate it. > > If this is too annoying, we can use the reinterpret_cast solution: > > template<typename T, typename U> > WeakReference<T>& static_weak_reference_cast(WeakReference<U>& weakReference) > { > static_assert(std::is_convertible<T*, U*>::value, "U* must be convertible to T*"); > return reinterpret_cast<WeakReference <T>&>(weakReference); > } > > Then createWeakPtr would static_weak_reference_cast m_ref when creating a WeakPtr. Sure. The first solution will definitely resolve this issue for us. I was trying to upload two patches, one for each, yesterday, but was not able to accomplish that. Building for WTF is too costly, I am wondering if it is possible to just build WTF and corresponding API tests. 1353191 15 321978 jiewen_tan 2017-09-27 11:18:57 -0700 Created attachment 321978 Second Solution 1353192 16 buildbot 2017-09-27 11:21:39 -0700 Attachment 321978 did not pass style-queue: ERROR: Source/WTF/wtf/WeakPtr.h:66: Should be indented on a separate line, with the colon or comma first on that line. [whitespace/indent] [4] ERROR: Source/WTF/wtf/WeakPtr.h:67: Should be indented on a separate line, with the colon or comma first on that line. [whitespace/indent] [4] ERROR: Source/WTF/wtf/WeakPtr.h:83: Should be indented on a separate line, with the colon or comma first on that line. [whitespace/indent] [4] Total errors found: 3 in 5 files If any of these errors are false positives, please file a bug against check-webkit-style. 1353195 17 jiewen_tan 2017-09-27 11:27:28 -0700 (In reply to Jiewen Tan from comment #14) > Comment on attachment 321940 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=321940&action=review > > Thanks Geoff for reviewing the patch. I will upload a patch addressing > comments in this patch and then upload another that uses the first solution. > Then we can decide which one to go. > > >>> Source/WTF/wtf/WeakPtr.h:88 > >>> + static_assert((!std::is_class<U>::value && !std::is_class<T>::value) || std::is_base_of<U, T>::value, "U should be a base class of T"); > >> > >> There's no need for this assertion because it's built into the static_cast. The value of the double template parameter solution is that you don't need any assertions: The language guarantees correctness. > > > > ...built into the static_cast in the getter. > > Removed. > > >>> Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp:215 > >>> + WeakPtr<Derived, Base> derivedWeakPtr; > >> > >> Ryosuke and I are kind of worrying this format will be annoying to use. However, I don't know how it could be prevented, i.e. using WeakPtr<Derived> instead of WeakPtr<Derived, Base>. If anyone has any ideas, please tell me. Appreciate it. > > > > If this is too annoying, we can use the reinterpret_cast solution: > > > > template<typename T, typename U> > > WeakReference<T>& static_weak_reference_cast(WeakReference<U>& weakReference) > > { > > static_assert(std::is_convertible<T*, U*>::value, "U* must be convertible to T*"); > > return reinterpret_cast<WeakReference <T>&>(weakReference); > > } > > > > Then createWeakPtr would static_weak_reference_cast m_ref when creating a WeakPtr. > > Sure. The first solution will definitely resolve this issue for us. I was > trying to upload two patches, one for each, yesterday, but was not able to > accomplish that. Building for WTF is too costly, I am wondering if it is > possible to just build WTF and corresponding API tests. Hmm, I could build WTF and TestWebKitAPI separately. 1353221 18 321989 jiewen_tan 2017-09-27 12:00:27 -0700 Created attachment 321989 First Solution 1353224 19 buildbot 2017-09-27 12:03:33 -0700 Attachment 321989 did not pass style-queue: ERROR: Source/WTF/wtf/WeakPtr.h:71: Should be indented on a separate line, with the colon or comma first on that line. [whitespace/indent] [4] Total errors found: 1 in 5 files If any of these errors are false positives, please file a bug against check-webkit-style. 1353939 20 321989 jiewen_tan 2017-09-27 16:58:27 -0700 Comment on attachment 321989 First Solution View in context: https://bugs.webkit.org/attachment.cgi?id=321989&action=review > Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp:228 > + EXPECT_EQ(derivedWeakPtr->foo(), dummy1); It should be derivedPtr. 1353942 21 321978 jiewen_tan 2017-09-27 16:59:24 -0700 Comment on attachment 321978 Second Solution View in context: https://bugs.webkit.org/attachment.cgi?id=321978&action=review > Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp:228 > + EXPECT_EQ(derivedWeakPtr->foo(), dummy1); It should be derivedPtr. 1353982 22 321989 rniwa 2017-09-27 18:45:05 -0700 Comment on attachment 321989 First Solution View in context: https://bugs.webkit.org/attachment.cgi?id=321989&action=review > Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp:215 > + WeakPtr<Base> baseWeakPtr; > + WeakPtr<Derived> derivedWeakPtr; This looks much better to me. 1353983 23 zalan 2017-09-27 18:46:35 -0700 (In reply to Ryosuke Niwa from comment #22) > Comment on attachment 321989 [details] > First Solution > > View in context: > https://bugs.webkit.org/attachment.cgi?id=321989&action=review > > > Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp:215 > > + WeakPtr<Base> baseWeakPtr; > > + WeakPtr<Derived> derivedWeakPtr; > > This looks much better to me. So much better. 1353999 24 321989 dbates 2017-09-27 19:54:31 -0700 Comment on attachment 321989 First Solution View in context: https://bugs.webkit.org/attachment.cgi?id=321989&action=review >>> Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp:215 >>> + WeakPtr<Derived> derivedWeakPtr; >> >> This looks much better to me. > > So much better. Better :) 1354277 25 321989 ggaren 2017-09-28 14:04:10 -0700 Comment on attachment 321989 First Solution r=me 1354295 26 321989 commit-queue 2017-09-28 14:31:43 -0700 Comment on attachment 321989 First Solution Clearing flags on attachment: 321989 Committed r222633: <http://trac.webkit.org/changeset/222633> 321758 2017-09-25 15:26:44 -0700 2017-09-26 09:36:14 -0700 Patch bug-177389-20170925152643.patch text/plain 3638 zalan U3VidmVyc2lvbiBSZXZpc2lvbjogMjIyNDIyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDdmNGQwYmZlY2IyODRkMzA2NDVhYzRi YWVmNTk3YmI1NzA2Y2JjNWIuLjQ3YzFkZDE5ODUwZjIwYTljYjg5ZGU1ZjJhZTk4MzVhN2EyNjg5 YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTctMDktMjUgIFphbGFuIEJ1anRhcyAgPHphbGFu QGFwcGxlLmNvbT4KKworICAgICAgICBXZWFrUHRyRmFjdG9yeSBzaG91bGQgYWxsb3cgZG93bmNh c3RpbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3 NzM4OQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMzQ2MDQxNzQ+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgWmFsYW4gQnVqdGFzLgorCisgICAgICAgIFBhdGNoIGJ5IEdlb2ZmcmV5IEdhcmVuLgor CisgICAgICAgIE5vIGNoYW5nZSBpbiBmdW5jdGlvbmFsaXR5LgorCisgICAgICAgICogd3RmL1dl YWtQdHIuaDoKKyAgICAgICAgKFdURjo6V2Vha1B0ckZhY3Rvcnk6OmNyZWF0ZVdlYWtQdHIgY29u c3QpOgorCiAyMDE3LTA5LTIyICBaYWxhbiBCdWp0YXMgIDx6YWxhbkBhcHBsZS5jb20+CiAKICAg ICAgICAgV2Vha1B0ckZhY3Rvcnkgc2hvdWxkIHBvcHVsYXRlIG1fcmVmIGxhemlseS4KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZwppbmRleCAyZDQ0YjcyNjVhYTdlNjExOWQ3OTNhYjczYmY3MmFlYjQ1YTAxZTkwLi4yOGEzZWEy OGMzNjBhMDUwYWVmODFmN2JiMWYzYWE1ZmM2NDYxM2IwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTggQEAKKzIwMTctMDktMjUgIFphbGFuIEJ1anRhcyAgPHphbGFuQGFwcGxlLmNvbT4KKworICAg ICAgICBXZWFrUHRyRmFjdG9yeSBzaG91bGQgYWxsb3cgZG93bmNhc3RpbmcKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NzM4OQorICAgICAgICA8cmRh cjovL3Byb2JsZW0vMzQ2MDQxNzQ+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgWmFsYW4gQnVqdGFz LgorCisgICAgICAgIFBhdGNoIGJ5IEdlb2ZmcmV5IEdhcmVuLgorCisgICAgICAgIE5vIGNoYW5n ZSBpbiBmdW5jdGlvbmFsaXR5LgorCisgICAgICAgICogbG9hZGVyL01lZGlhUmVzb3VyY2VMb2Fk ZXIuaDoKKyAgICAgICAgKiBzdmcvcHJvcGVydGllcy9TVkdNYXRyaXhUZWFyT2ZmLmg6CisKIDIw MTctMDktMjIgIFphbGFuIEJ1anRhcyAgPHphbGFuQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWFr UHRyRmFjdG9yeSBzaG91bGQgcG9wdWxhdGUgbV9yZWYgbGF6aWx5LgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dURi93dGYvV2Vha1B0ci5oIGIvU291cmNlL1dURi93dGYvV2Vha1B0ci5oCmluZGV4IGJk MmY1NDQzZGU5MWEwODJmN2FlZjM0MjM1NTJmMTlkMTkyMGVkYTYuLmQ4NGRlNjdmZGE0NjU5YzMy NmY4ZTlmZDBjNzY4ZjA3Mzg0MzZmOTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1dlYWtQ dHIuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9XZWFrUHRyLmgKQEAgLTEwMCwxMiArMTAwLDEyIEBA IHB1YmxpYzoKICAgICAgICAgbV9yZWYtPmNsZWFyKCk7CiAgICAgfQogCi0gICAgV2Vha1B0cjxU PiBjcmVhdGVXZWFrUHRyKFQmIHB0cikgY29uc3QKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBX ZWFrUHRyPFU+IGNyZWF0ZVdlYWtQdHIoVSYgcHRyKSBjb25zdAogICAgIHsKICAgICAgICAgaWYg KCFtX3JlZikKICAgICAgICAgICAgIG1fcmVmID0gV2Vha1JlZmVyZW5jZTxUPjo6Y3JlYXRlKCZw dHIpOwogICAgICAgICBBU1NFUlQoJnB0ciA9PSBtX3JlZi0+Z2V0KCkpOwotICAgICAgICByZXR1 cm4gV2Vha1B0cjxUPihSZWY8V2Vha1JlZmVyZW5jZTxUPj4oKm1fcmVmKSk7CisgICAgICAgIHJl dHVybiBXZWFrUHRyPFU+KFJlZjxXZWFrUmVmZXJlbmNlPFU+PihzdGF0aWNfY2FzdDxXZWFrUmVm ZXJlbmNlPFU+Jj4oKm1fcmVmKSkpOwogICAgIH0KIAogICAgIHZvaWQgcmV2b2tlQWxsKCkKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9NZWRpYVJlc291cmNlTG9hZGVyLmggYi9T b3VyY2UvV2ViQ29yZS9sb2FkZXIvTWVkaWFSZXNvdXJjZUxvYWRlci5oCmluZGV4IGIwMDRiN2Fk MWQxOGFlNzcxZDcyYWQ4ODIzNzQ5ZDMyNTM3MTI2MjMuLmY0NjFmY2E3NGI0ODRhOGZhMTdhYTM5 YTFiYWE1MTQyOWZkMWZhMzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9NZWRp YVJlc291cmNlTG9hZGVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL01lZGlhUmVzb3Vy Y2VMb2FkZXIuaApAQCAtNTgsNyArNTgsNyBAQCBwdWJsaWM6CiAgICAgVmVjdG9yPFJlc291cmNl UmVzcG9uc2U+IHJlc3BvbnNlc0ZvclRlc3RpbmcoKSBjb25zdCB7IHJldHVybiBtX3Jlc3BvbnNl c0ZvclRlc3Rpbmc7IH0KICAgICB2b2lkIGFkZFJlc3BvbnNlRm9yVGVzdGluZyhjb25zdCBSZXNv dXJjZVJlc3BvbnNlJik7CiAKLSAgICBXZWFrUHRyPGNvbnN0IE1lZGlhUmVzb3VyY2VMb2FkZXI+ IGNyZWF0ZVdlYWtQdHIoKSB7IHJldHVybiBtX3dlYWtGYWN0b3J5LmNyZWF0ZVdlYWtQdHIoKnRo aXMpOyB9CisgICAgV2Vha1B0cjxjb25zdCBNZWRpYVJlc291cmNlTG9hZGVyPiBjcmVhdGVXZWFr UHRyKCkgeyByZXR1cm4gbV93ZWFrRmFjdG9yeS5jcmVhdGVXZWFrUHRyPGNvbnN0IE1lZGlhUmVz b3VyY2VMb2FkZXI+KCp0aGlzKTsgfQogCiBwcml2YXRlOgogICAgIHZvaWQgY29udGV4dERlc3Ry b3llZCgpIG92ZXJyaWRlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRp ZXMvU1ZHTWF0cml4VGVhck9mZi5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZH TWF0cml4VGVhck9mZi5oCmluZGV4IGUwYmYwZDA4MjdlNzNmN2ZjOGZmZDIwOTMwOWRmMDFlM2My OTlhMTUuLjUxYmY1ZWQ3Yzc2YzEzYTMzODgwNzk0MDgzY2UxZTNjNjlhOWI5M2IgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR01hdHJpeFRlYXJPZmYuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdNYXRyaXhUZWFyT2ZmLmgKQEAgLTMw LDcgKzMwLDcgQEAgcHVibGljOgogICAgIHsKICAgICAgICAgQVNTRVJUX1VOVVNFRCh2YWx1ZSwg JnBhcmVudC5wcm9wZXJ0eVJlZmVyZW5jZSgpLnN2Z01hdHJpeCgpID09ICZ2YWx1ZSk7CiAgICAg ICAgIFJlZjxTVkdNYXRyaXhUZWFyT2ZmPiByZXN1bHQgPSBhZG9wdFJlZigqbmV3IFNWR01hdHJp eFRlYXJPZmYocGFyZW50KSk7Ci0gICAgICAgIHBhcmVudC5hZGRDaGlsZChyZXN1bHQtPm1fd2Vh a0ZhY3RvcnkuY3JlYXRlV2Vha1B0cihyZXN1bHQpKTsKKyAgICAgICAgcGFyZW50LmFkZENoaWxk KHJlc3VsdC0+bV93ZWFrRmFjdG9yeS5jcmVhdGVXZWFrUHRyPFNWR1Byb3BlcnR5VGVhck9mZkJh c2U+KHJlc3VsdCkpOwogICAgICAgICByZXR1cm4gcmVzdWx0OwogICAgIH0KIAo= 321940 2017-09-26 23:54:54 -0700 2017-09-27 11:18:56 -0700 Patch bug-177389-20170926235453.patch text/plain 11146 jiewen_tan U3VidmVyc2lvbiBSZXZpc2lvbjogMjIyNDYwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDRiMGRmN2NjODJkMzg3NjFkOGE3MTE1 ZjExMmRmMTdkM2Q1YzRkMjYuLmZmMmY1M2FiYmJmMjdmOWYwNjdiZjRiZGJmMThhZjUzZGU5MDgz M2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMTctMDktMjYgIEppZXdlbiBUYW4gIDxqaWV3ZW5f dGFuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWFrUHRyRmFjdG9yeSBzaG91bGQgYWxsb3cgZG93 bmNhc3RpbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE3NzM4OQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMzQ2MDQxNzQ+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSW4gdGhpcyBwYXRjaCwgYSBzZWNv bmQgdGVtcGxhdGUgcGFyYW1ldGVyIGlzIGFkZGVkIHRvIFdlYWtQdHIgc3VjaCB0aGF0IGl0Cisg ICAgICAgIGNhbiBob2xkIGEgV2Vha1JlZmVyZW5jZSBvZiBhIGJhc2UgY2xhc3Mgd2hpbGUgcmV0 dXJuIGEgcG9pbnRlciBvZiBhIGRlcml2ZWQKKyAgICAgICAgY2xhc3MuIFNvLCBhIFdlYWtQdHJG YWN0b3J5IGNhbiB0aGVuIGNyZWF0ZSBXZWFrUHRycyB0aGF0IGFyZSBkZXJpdmVkIGNsYXNzZXMK KyAgICAgICAgb2YgaXRzIG93bmVyIGFuZCBoYXZlIHRoZW0gcG9pbnQgdG8gdGhlIHNhbWUgV2Vh a1JlZmVyZW5jZSBvZiBpdHMgb3duZXIncyB0eXBlLgorCisgICAgICAgICogd3RmL1dlYWtQdHIu aDoKKyAgICAgICAgKFdURjo6V2Vha1JlZmVyZW5jZTo6Y3JlYXRlKToKKyAgICAgICAgSXQgaXMg bWFkZSBwdWJsaWMgYXMgd2UgY2Fubm90IGRlY2xhcmUgZnJpZW5kIGNsYXNzZXMgb2YgcGFydGlh bCBzcGVjaWFsaXphdGlvbnMuCisgICAgICAgIChXVEY6OldlYWtQdHI6OldlYWtQdHIpOgorICAg ICAgICAoV1RGOjpXZWFrUHRyOjpnZXQgY29uc3QpOgorICAgICAgICAoV1RGOjpXZWFrUHRyOjpv cGVyYXRvcj0pOgorICAgICAgICAoV1RGOjpXZWFrUHRyOjpvcGVyYXRvci0+IGNvbnN0KToKKyAg ICAgICAgKFdURjo6V2Vha1B0cjo6Y2xlYXIpOgorICAgICAgICAoV1RGOjpXZWFrUHRyRmFjdG9y eTo6Y3JlYXRlV2Vha1B0ciBjb25zdCk6CisgICAgICAgIChXVEY6Om9wZXJhdG9yPT0pOgorICAg ICAgICAoV1RGOjpvcGVyYXRvciE9KToKKwogMjAxNy0wOS0yMyAgU2FpZCBBYm91LUhhbGxhd2Eg IDxzYWJvdWhhbGxhd2FAYXBwbGUuY29tPgogCiAgICAgICAgIEltYWdlcyBtYXkgcmVuZGVyIHBh cnRpYWwgZnJhbWVzIGV2ZW4gYWZ0ZXIgbG9hZGluZyBhbGwgdGhlIGVuY29kZWQgZGF0YQpkaWZm IC0tZ2l0IGEvU291cmNlL1dURi93dGYvV2Vha1B0ci5oIGIvU291cmNlL1dURi93dGYvV2Vha1B0 ci5oCmluZGV4IGJkMmY1NDQzZGU5MWEwODJmN2FlZjM0MjM1NTJmMTlkMTkyMGVkYTYuLjUwYTYw NjU2NzZmMWFiYjAyMTc0NzFlNDBmNjUyNjRkYWI5MWQzOWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X VEYvd3RmL1dlYWtQdHIuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9XZWFrUHRyLmgKQEAgLTI3LDYg KzI3LDggQEAKICNpZm5kZWYgV1RGX1dlYWtQdHJfaAogI2RlZmluZSBXVEZfV2Vha1B0cl9oCiAK KyNpbmNsdWRlIDx0eXBlX3RyYWl0cz4KKwogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgog I2luY2x1ZGUgPHd0Zi9SZWYuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFkU2FmZVJlZkNvdW50ZWQu aD4KQEAgLTM0LDcgKzM2LDYgQEAKIAogbmFtZXNwYWNlIFdURiB7CiAKLXRlbXBsYXRlPHR5cGVu YW1lIFQ+IGNsYXNzIFdlYWtQdHI7CiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBjbGFzcyBXZWFrUHRy RmFjdG9yeTsKIAogLy8gTm90ZTogV2Vha1JlZmVyZW5jZSBpcyBhbiBpbXBsZW1lbnRhdGlvbiBk ZXRhaWwsIGFuZCBzaG91bGQgbm90IGJlIHVzZWQgZGlyZWN0bHkuCkBAIC00MywxNiArNDQsMTUg QEAgY2xhc3MgV2Vha1JlZmVyZW5jZSA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxXZWFr UmVmZXJlbmNlPFQ+PiB7CiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoV2Vha1JlZmVyZW5jZTxU Pik7CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiBwdWJsaWM6CisgICAgc3RhdGljIFJl ZjxXZWFrUmVmZXJlbmNlPFQ+PiBjcmVhdGUoVCogcHRyKSB7IHJldHVybiBhZG9wdFJlZigqbmV3 IFdlYWtSZWZlcmVuY2UocHRyKSk7IH0KKwogICAgIFQqIGdldCgpIGNvbnN0IHsgcmV0dXJuIG1f cHRyOyB9CiAKICAgICB2b2lkIGNsZWFyKCkgeyBtX3B0ciA9IG51bGxwdHI7IH0KIAogcHJpdmF0 ZToKLSAgICBmcmllbmQgY2xhc3MgV2Vha1B0cjxUPjsKICAgICBmcmllbmQgY2xhc3MgV2Vha1B0 ckZhY3Rvcnk8VD47CiAKLSAgICBzdGF0aWMgUmVmPFdlYWtSZWZlcmVuY2U8VD4+IGNyZWF0ZShU KiBwdHIpIHsgcmV0dXJuIGFkb3B0UmVmKCpuZXcgV2Vha1JlZmVyZW5jZShwdHIpKTsgfQotCiAg ICAgZXhwbGljaXQgV2Vha1JlZmVyZW5jZShUKiBwdHIpCiAgICAgICAgIDogbV9wdHIocHRyKQog ICAgIHsKQEAgLTYxLDMwICs2MSwzNCBAQCBwcml2YXRlOgogICAgIFQqIG1fcHRyOwogfTsKIAot dGVtcGxhdGU8dHlwZW5hbWUgVD4KK3RlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFUgPSBU PgogY2xhc3MgV2Vha1B0ciB7CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiBwdWJsaWM6 Ci0gICAgV2Vha1B0cigpIDogbV9yZWYoV2Vha1JlZmVyZW5jZTxUPjo6Y3JlYXRlKG51bGxwdHIp KSB7IH0KLSAgICBXZWFrUHRyKHN0ZDo6bnVsbHB0cl90KSA6IG1fcmVmKFdlYWtSZWZlcmVuY2U8 VD46OmNyZWF0ZShudWxscHRyKSkgeyB9CisgICAgV2Vha1B0cigpOiBtX3JlZihXZWFrUmVmZXJl bmNlPFU+OjpjcmVhdGUobnVsbHB0cikpIHsgfQorICAgIFdlYWtQdHIoc3RkOjpudWxscHRyX3Qp IDogbV9yZWYoV2Vha1JlZmVyZW5jZTxVPjo6Y3JlYXRlKG51bGxwdHIpKSB7IH0KICAgICBXZWFr UHRyKGNvbnN0IFdlYWtQdHImIG8pIDogbV9yZWYoby5tX3JlZi5jb3B5UmVmKCkpIHsgfQotICAg IHRlbXBsYXRlPHR5cGVuYW1lIFU+IFdlYWtQdHIoY29uc3QgV2Vha1B0cjxVPiYgbykgOiBtX3Jl ZihvLm1fcmVmLmNvcHlSZWYoKSkgeyB9CiAKLSAgICBUKiBnZXQoKSBjb25zdCB7IHJldHVybiBt X3JlZi0+Z2V0KCk7IH0KKyAgICBUKiBnZXQoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxU Kj4obV9yZWYtPmdldCgpKTsgfQogICAgIG9wZXJhdG9yIGJvb2woKSBjb25zdCB7IHJldHVybiBt X3JlZi0+Z2V0KCk7IH0KIAogICAgIFdlYWtQdHImIG9wZXJhdG9yPShjb25zdCBXZWFrUHRyJiBv KSB7IG1fcmVmID0gby5tX3JlZi5jb3B5UmVmKCk7IHJldHVybiAqdGhpczsgfQotICAgIFdlYWtQ dHImIG9wZXJhdG9yPShzdGQ6Om51bGxwdHJfdCkgeyBtX3JlZiA9IFdlYWtSZWZlcmVuY2U8VD46 OmNyZWF0ZShudWxscHRyKTsgcmV0dXJuICp0aGlzOyB9CisgICAgV2Vha1B0ciYgb3BlcmF0b3I9 KHN0ZDo6bnVsbHB0cl90KSB7IG1fcmVmID0gV2Vha1JlZmVyZW5jZTxVPjo6Y3JlYXRlKG51bGxw dHIpOyByZXR1cm4gKnRoaXM7IH0KIAotICAgIFQqIG9wZXJhdG9yLT4oKSBjb25zdCB7IHJldHVy biBtX3JlZi0+Z2V0KCk7IH0KKyAgICBUKiBvcGVyYXRvci0+KCkgY29uc3QgeyByZXR1cm4gc3Rh dGljX2Nhc3Q8VCo+KG1fcmVmLT5nZXQoKSk7IH0KIAotICAgIHZvaWQgY2xlYXIoKSB7IG1fcmVm ID0gV2Vha1JlZmVyZW5jZTxUPjo6Y3JlYXRlKG51bGxwdHIpOyB9CisgICAgdm9pZCBjbGVhcigp IHsgbV9yZWYgPSBXZWFrUmVmZXJlbmNlPFU+OjpjcmVhdGUobnVsbHB0cik7IH0KIAogcHJpdmF0 ZToKLSAgICBmcmllbmQgY2xhc3MgV2Vha1B0ckZhY3Rvcnk8VD47Ci0gICAgV2Vha1B0cihSZWY8 V2Vha1JlZmVyZW5jZTxUPj4mJiByZWYpIDogbV9yZWYoc3RkOjpmb3J3YXJkPFJlZjxXZWFrUmVm ZXJlbmNlPFQ+Pj4ocmVmKSkgeyB9CisgICAgZnJpZW5kIGNsYXNzIFdlYWtQdHJGYWN0b3J5PFU+ OworCisgICAgV2Vha1B0cihSZWY8V2Vha1JlZmVyZW5jZTxVPj4mJiByZWYpCisgICAgICAgIDog bV9yZWYoc3RkOjpmb3J3YXJkPFJlZjxXZWFrUmVmZXJlbmNlPFU+Pj4ocmVmKSkKKyAgICB7Cisg ICAgICAgIHN0YXRpY19hc3NlcnQoKCFzdGQ6OmlzX2NsYXNzPFU+Ojp2YWx1ZSAmJiAhc3RkOjpp c19jbGFzczxUPjo6dmFsdWUpIHx8IHN0ZDo6aXNfYmFzZV9vZjxVLCBUPjo6dmFsdWUsICJVIHNo b3VsZCBiZSBhIGJhc2UgY2xhc3Mgb2YgVCIpOworICAgIH0KIAotICAgIFJlZjxXZWFrUmVmZXJl bmNlPFQ+PiBtX3JlZjsKKyAgICBSZWY8V2Vha1JlZmVyZW5jZTxVPj4gbV9yZWY7CiB9OwogCiB0 ZW1wbGF0ZTx0eXBlbmFtZSBUPgpAQCAtMTAwLDEyICsxMDQsMTMgQEAgcHVibGljOgogICAgICAg ICBtX3JlZi0+Y2xlYXIoKTsKICAgICB9CiAKLSAgICBXZWFrUHRyPFQ+IGNyZWF0ZVdlYWtQdHIo VCYgcHRyKSBjb25zdAorICAgIHRlbXBsYXRlPHR5cGVuYW1lIFUgPSBUPgorICAgIFdlYWtQdHI8 VSwgVD4gY3JlYXRlV2Vha1B0cihUJiBwdHIpIGNvbnN0CiAgICAgewogICAgICAgICBpZiAoIW1f cmVmKQogICAgICAgICAgICAgbV9yZWYgPSBXZWFrUmVmZXJlbmNlPFQ+OjpjcmVhdGUoJnB0cik7 CiAgICAgICAgIEFTU0VSVCgmcHRyID09IG1fcmVmLT5nZXQoKSk7Ci0gICAgICAgIHJldHVybiBX ZWFrUHRyPFQ+KFJlZjxXZWFrUmVmZXJlbmNlPFQ+PigqbV9yZWYpKTsKKyAgICAgICAgcmV0dXJu IFdlYWtQdHI8VSwgVD4oUmVmPFdlYWtSZWZlcmVuY2U8VD4+KCptX3JlZikpOwogICAgIH0KIAog ICAgIHZvaWQgcmV2b2tlQWxsKCkKQEAgLTEyMSwzMiArMTI2LDMyIEBAIHByaXZhdGU6CiAgICAg bXV0YWJsZSBSZWZQdHI8V2Vha1JlZmVyZW5jZTxUPj4gbV9yZWY7CiB9OwogCi10ZW1wbGF0ZTx0 eXBlbmFtZSBULCB0eXBlbmFtZSBVPiBpbmxpbmUgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFdlYWtQ dHI8VD4mIGEsIGNvbnN0IFdlYWtQdHI8VT4mIGIpCit0ZW1wbGF0ZTx0eXBlbmFtZSBULCB0eXBl bmFtZSBVLCB0eXBlbmFtZSBWLCB0eXBlbmFtZSBXPiBpbmxpbmUgYm9vbCBvcGVyYXRvcj09KGNv bnN0IFdlYWtQdHI8VCwgVj4mIGEsIGNvbnN0IFdlYWtQdHI8VSwgVz4mIGIpCiB7CiAgICAgcmV0 dXJuIGEuZ2V0KCkgPT0gYi5nZXQoKTsKIH0KIAotdGVtcGxhdGU8dHlwZW5hbWUgVCwgdHlwZW5h bWUgVT4gaW5saW5lIGJvb2wgb3BlcmF0b3I9PShjb25zdCBXZWFrUHRyPFQ+JiBhLCBVKiBiKQor dGVtcGxhdGU8dHlwZW5hbWUgVCwgdHlwZW5hbWUgVSwgdHlwZW5hbWUgVj4gaW5saW5lIGJvb2wg b3BlcmF0b3I9PShjb25zdCBXZWFrUHRyPFQsIFY+JiBhLCBVKiBiKQogewogICAgIHJldHVybiBh LmdldCgpID09IGI7CiB9CiAKLXRlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFU+IGlubGlu ZSBib29sIG9wZXJhdG9yPT0oVCogYSwgY29uc3QgV2Vha1B0cjxVPiYgYikKK3RlbXBsYXRlPHR5 cGVuYW1lIFQsIHR5cGVuYW1lIFUsIHR5cGVuYW1lIFY+IGlubGluZSBib29sIG9wZXJhdG9yPT0o VCogYSwgY29uc3QgV2Vha1B0cjxVLCBWPiYgYikKIHsKICAgICByZXR1cm4gYSA9PSBiLmdldCgp OwogfQogCi10ZW1wbGF0ZTx0eXBlbmFtZSBULCB0eXBlbmFtZSBVPiBpbmxpbmUgYm9vbCBvcGVy YXRvciE9KGNvbnN0IFdlYWtQdHI8VD4mIGEsIGNvbnN0IFdlYWtQdHI8VT4mIGIpCit0ZW1wbGF0 ZTx0eXBlbmFtZSBULCB0eXBlbmFtZSBVLCB0eXBlbmFtZSBWLCB0eXBlbmFtZSBXPiBpbmxpbmUg Ym9vbCBvcGVyYXRvciE9KGNvbnN0IFdlYWtQdHI8VCwgVj4mIGEsIGNvbnN0IFdlYWtQdHI8VSwg Vz4mIGIpCiB7CiAgICAgcmV0dXJuIGEuZ2V0KCkgIT0gYi5nZXQoKTsKIH0KIAotdGVtcGxhdGU8 dHlwZW5hbWUgVCwgdHlwZW5hbWUgVT4gaW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBXZWFr UHRyPFQ+JiBhLCBVKiBiKQordGVtcGxhdGU8dHlwZW5hbWUgVCwgdHlwZW5hbWUgVSwgdHlwZW5h bWUgVj4gaW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBXZWFrUHRyPFQsIFY+JiBhLCBVKiBi KQogewogICAgIHJldHVybiBhLmdldCgpICE9IGI7CiB9CiAKLXRlbXBsYXRlPHR5cGVuYW1lIFQs IHR5cGVuYW1lIFU+IGlubGluZSBib29sIG9wZXJhdG9yIT0oVCogYSwgY29uc3QgV2Vha1B0cjxV PiYgYikKK3RlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFUsIHR5cGVuYW1lIFY+IGlubGlu ZSBib29sIG9wZXJhdG9yIT0oVCogYSwgY29uc3QgV2Vha1B0cjxVLCBWPiYgYikKIHsKICAgICBy ZXR1cm4gYSAhPSBiLmdldCgpOwogfQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9v bHMvQ2hhbmdlTG9nCmluZGV4IGRlMTdkNTk4ZTE0M2ViNTZiZjkyNTQ4MDU3ZWJkOGQyYmZkZjAz ZmIuLjVhMDMzNDA5MmUyOGM4ZGE1OWYxMjQ4OWFlNjkyNzg5M2E5MjBjY2MgMTAwNjQ0Ci0tLSBh L1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOCBAQAor MjAxNy0wOS0yNiAgSmlld2VuIFRhbiAgPGppZXdlbl90YW5AYXBwbGUuY29tPgorCisgICAgICAg IFdlYWtQdHJGYWN0b3J5IHNob3VsZCBhbGxvdyBkb3duY2FzdGluZworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc3Mzg5CisgICAgICAgIDxyZGFyOi8v cHJvYmxlbS8zNDYwNDE3ND4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dlYWtQdHIuY3Bw OgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6QmFzZTo6Zm9vKToKKyAgICAgICAgKFRlc3RXZWJL aXRBUEk6OkJhc2U6OmNyZWF0ZVdlYWtQdHIpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6RGVy aXZlZDo6Zm9vKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDE3LTA5LTI1 ICBQZXIgQXJuZSBWb2xsYW4gIDxwdm9sbGFuQGFwcGxlLmNvbT4KIAogICAgICAgICBbV2luXSBy dW4tYXBpLXRlc3RzIGlzIGZhaWxpbmcuCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGNlMTBi ZTllMTYxMDVkNDMwODMxOTczZWIwMTY3YWQwNDBkMzE1NDEuLjIyMzc3Mzg4ZTEwNmFiYWRjODRm YjcyNjFhMjdlNDJiZGEzY2FmMjAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0yMTYsNiAr MjE2LDcgQEAKIAkJNTc5MDFGQjExQ0FGMTQyRDAwRUQ2NEY5IC8qIExvYWRJbnZhbGlkVVJMUmVx dWVzdC5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDU3OTAxRkIwMUNBRjE0MUMwMEVENjRGOSAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3Qu aHRtbCAqLzsgfTsKIAkJNTc5N0ZFMzExRUIxNUE2ODAwQjJGNEEwIC8qIE5hdmlnYXRpb25DbGll bnREZWZhdWx0Q3J5cHRvLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDU3OTdGRTJGMUVCMTVBNUYwMEIyRjRBMCAvKiBOYXZpZ2F0aW9uQ2xpZW50RGVm YXVsdENyeXB0by5jcHAgKi87IH07CiAJCTU3OTdGRTMzMUVCMTVBQjEwMEIyRjRBMCAvKiBuYXZp Z2F0aW9uLWNsaWVudC1kZWZhdWx0LWNyeXB0by5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDU3OTdGRTMyMUVCMTVBODkwMEIyRjRBMCAv KiBuYXZpZ2F0aW9uLWNsaWVudC1kZWZhdWx0LWNyeXB0by5odG1sICovOyB9OworCQk1N0MzRkE2 NTFGN0IwQjQ4MDA5RDRCODAgLyogV2Vha1B0ci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAxQ0I5QkMzNzFBNjc0ODIzMDBGRTU2NzggLyogV2Vha1B0 ci5jcHAgKi87IH07CiAJCTU3RjU2QTVDMUM3RjhDQzEwMEYzMUQ3RSAvKiBJc05hdmlnYXRpb25B Y3Rpb25UcnVzdGVkLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNTdGNTZBNUIxQzdGOEE0MDAwRjMxRDdFIC8qIElzTmF2aWdhdGlvbkFj dGlvblRydXN0ZWQuaHRtbCAqLzsgfTsKIAkJNUMwQkY4OEQxREQ1OTY0RDAwQjAwMzI4IC8qIE1l bW9yeVByZXNzdXJlSGFuZGxlci5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDVDMEJGODhDMURENTk1NzQwMEIwMDMyOCAvKiBNZW1vcnlQcmVzc3VyZUhh bmRsZXIubW0gKi87IH07CiAJCTVDMEJGODkxMURENTk5QTkwMEIwMDMyOCAvKiBXZWJWaWV3Q2Fu UGFzdGVaZXJvUG5nLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gNUMwQkY4OEYxREQ1OTk5QjAwQjAwMzI4IC8qIFdlYlZpZXdDYW5QYXN0ZVplcm9Qbmcu bW0gKi87IH07CkBAIC0zMTEwLDYgKzMxMTEsNyBAQAogCQkJCTdDODNGQzcxMUQ1NTM1QTgwMDFE RkJDRCAvKiBWYXJpYW50LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdDODNERjRDMUQwQTU5MEMw MEZFQkNGMyAvKiBWZWN0b3IuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMzdDN0NDMkQxRUE0MTQ2 QjAwN0JEOTU2IC8qIFdlYWtMaW5raW5nLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTU3QzNGQTY1 MUY3QjBCNDgwMDlENEI4MCAvKiBXZWFrUHRyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdDODNE RjYzMUQwQTU5MEMwMEZFQkNGMyAvKiBXVEZTdHJpbmcuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkp OwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CmRpZmYgLS1naXQg YS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9XZWFrUHRyLmNwcCBiL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvV1RGL1dlYWtQdHIuY3BwCmluZGV4IDljNWFjNTlhN2M5N2QwMTI5MTdk ZGI3MzBmNTVkNzAyMWM3NTQ0ZjMuLmEzZmUxYmQzMTlmYWRiZTE1ODZjZTg4ODMyN2QxYzgyNjU5 ZDk2NTIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dlYWtQdHIu Y3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dlYWtQdHIuY3BwCkBAIC0x LDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNSBBcHBsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTUtMjAxNyBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTE4MCw1 ICsxODAsNjAgQEAgVEVTVChXVEZfV2Vha1B0ciwgRm9yZ2V0KQogICAgIHdlYWtQdHI3ID0gbnVs bHB0cjsKICAgICBFWFBFQ1RfTlVMTCh3ZWFrUHRyNy5nZXQoKSk7CiB9Ci0gICAgCisKK2NsYXNz IEJhc2UgeworcHVibGljOgorICAgIGludCBmb28oKQorICAgIHsKKyAgICAgICAgcmV0dXJuIDA7 CisgICAgfQorCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KKyAgICBXZWFrUHRyPFQsIEJhc2U+ IGNyZWF0ZVdlYWtQdHIoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fd2Vha1B0ckZhY3Rvcnku Y3JlYXRlV2Vha1B0cjxUPigqdGhpcyk7CisgICAgfQorCitwcml2YXRlOgorICAgIFdlYWtQdHJG YWN0b3J5PEJhc2U+IG1fd2Vha1B0ckZhY3Rvcnk7Cit9OworCitjbGFzcyBEZXJpdmVkIDogcHVi bGljIEJhc2UgeworcHVibGljOgorICAgIGludCBmb28oKQorICAgIHsKKyAgICAgICAgcmV0dXJu IDE7CisgICAgfQorfTsKKworVEVTVChXVEZfV2Vha1B0ciwgRG93bmNhc3RpbmcpCit7CisgICAg aW50IGR1bW15MCA9IDA7CisgICAgaW50IGR1bW15MSA9IDE7CisKKyAgICBXZWFrUHRyPEJhc2U+ IGJhc2VXZWFrUHRyOworICAgIFdlYWtQdHI8RGVyaXZlZCwgQmFzZT4gZGVyaXZlZFdlYWtQdHI7 CisKKyAgICB7CisgICAgICAgIERlcml2ZWQgb2JqZWN0OworICAgICAgICBEZXJpdmVkKiBkZXJp dmVkUHRyID0gJm9iamVjdDsKKyAgICAgICAgQmFzZSogYmFzZVB0ciA9IHN0YXRpY19jYXN0PEJh c2UqPigmb2JqZWN0KTsKKworICAgICAgICBiYXNlV2Vha1B0ciA9IG9iamVjdC5jcmVhdGVXZWFr UHRyPEJhc2U+KCk7CisgICAgICAgIEVYUEVDVF9FUShiYXNlUHRyLT5mb28oKSwgZHVtbXkwKTsK KyAgICAgICAgRVhQRUNUX0VRKGJhc2VXZWFrUHRyLT5mb28oKSwgYmFzZVB0ci0+Zm9vKCkpOwor ICAgICAgICBFWFBFQ1RfRVEoYmFzZVdlYWtQdHIuZ2V0KCktPmZvbygpLCBiYXNlUHRyLT5mb28o KSk7CisKKyAgICAgICAgZGVyaXZlZFdlYWtQdHIgPSBvYmplY3QuY3JlYXRlV2Vha1B0cjxEZXJp dmVkPigpOworICAgICAgICBFWFBFQ1RfRVEoZGVyaXZlZFdlYWtQdHItPmZvbygpLCBkdW1teTEp OworICAgICAgICBFWFBFQ1RfRVEoZGVyaXZlZFdlYWtQdHItPmZvbygpLCBkZXJpdmVkUHRyLT5m b28oKSk7CisgICAgICAgIEVYUEVDVF9FUShkZXJpdmVkV2Vha1B0ci5nZXQoKS0+Zm9vKCksIGRl cml2ZWRQdHItPmZvbygpKTsKKworICAgICAgICBFWFBFQ1RfRVEoYmFzZVdlYWtQdHIuZ2V0KCks IGRlcml2ZWRXZWFrUHRyLmdldCgpKTsKKyAgICB9CisKKyAgICBFWFBFQ1RfTlVMTChiYXNlV2Vh a1B0ci5nZXQoKSk7CisgICAgRVhQRUNUX05VTEwoZGVyaXZlZFdlYWtQdHIuZ2V0KCkpOworfQor CiB9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJCg== 321978 2017-09-27 11:18:57 -0700 2017-10-16 12:32:31 -0700 Second Solution bug-177389-20170927111857.patch text/plain 10798 jiewen_tan U3VidmVyc2lvbiBSZXZpc2lvbjogMjIyNDYwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDRiMGRmN2NjODJkMzg3NjFkOGE3MTE1 ZjExMmRmMTdkM2Q1YzRkMjYuLmZmMmY1M2FiYmJmMjdmOWYwNjdiZjRiZGJmMThhZjUzZGU5MDgz M2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMTctMDktMjYgIEppZXdlbiBUYW4gIDxqaWV3ZW5f dGFuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWFrUHRyRmFjdG9yeSBzaG91bGQgYWxsb3cgZG93 bmNhc3RpbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE3NzM4OQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMzQ2MDQxNzQ+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSW4gdGhpcyBwYXRjaCwgYSBzZWNv bmQgdGVtcGxhdGUgcGFyYW1ldGVyIGlzIGFkZGVkIHRvIFdlYWtQdHIgc3VjaCB0aGF0IGl0Cisg ICAgICAgIGNhbiBob2xkIGEgV2Vha1JlZmVyZW5jZSBvZiBhIGJhc2UgY2xhc3Mgd2hpbGUgcmV0 dXJuIGEgcG9pbnRlciBvZiBhIGRlcml2ZWQKKyAgICAgICAgY2xhc3MuIFNvLCBhIFdlYWtQdHJG YWN0b3J5IGNhbiB0aGVuIGNyZWF0ZSBXZWFrUHRycyB0aGF0IGFyZSBkZXJpdmVkIGNsYXNzZXMK KyAgICAgICAgb2YgaXRzIG93bmVyIGFuZCBoYXZlIHRoZW0gcG9pbnQgdG8gdGhlIHNhbWUgV2Vh a1JlZmVyZW5jZSBvZiBpdHMgb3duZXIncyB0eXBlLgorCisgICAgICAgICogd3RmL1dlYWtQdHIu aDoKKyAgICAgICAgKFdURjo6V2Vha1JlZmVyZW5jZTo6Y3JlYXRlKToKKyAgICAgICAgSXQgaXMg bWFkZSBwdWJsaWMgYXMgd2UgY2Fubm90IGRlY2xhcmUgZnJpZW5kIGNsYXNzZXMgb2YgcGFydGlh bCBzcGVjaWFsaXphdGlvbnMuCisgICAgICAgIChXVEY6OldlYWtQdHI6OldlYWtQdHIpOgorICAg ICAgICAoV1RGOjpXZWFrUHRyOjpnZXQgY29uc3QpOgorICAgICAgICAoV1RGOjpXZWFrUHRyOjpv cGVyYXRvcj0pOgorICAgICAgICAoV1RGOjpXZWFrUHRyOjpvcGVyYXRvci0+IGNvbnN0KToKKyAg ICAgICAgKFdURjo6V2Vha1B0cjo6Y2xlYXIpOgorICAgICAgICAoV1RGOjpXZWFrUHRyRmFjdG9y eTo6Y3JlYXRlV2Vha1B0ciBjb25zdCk6CisgICAgICAgIChXVEY6Om9wZXJhdG9yPT0pOgorICAg ICAgICAoV1RGOjpvcGVyYXRvciE9KToKKwogMjAxNy0wOS0yMyAgU2FpZCBBYm91LUhhbGxhd2Eg IDxzYWJvdWhhbGxhd2FAYXBwbGUuY29tPgogCiAgICAgICAgIEltYWdlcyBtYXkgcmVuZGVyIHBh cnRpYWwgZnJhbWVzIGV2ZW4gYWZ0ZXIgbG9hZGluZyBhbGwgdGhlIGVuY29kZWQgZGF0YQpkaWZm IC0tZ2l0IGEvU291cmNlL1dURi93dGYvV2Vha1B0ci5oIGIvU291cmNlL1dURi93dGYvV2Vha1B0 ci5oCmluZGV4IGJkMmY1NDQzZGU5MWEwODJmN2FlZjM0MjM1NTJmMTlkMTkyMGVkYTYuLmY4NzMy YTk1ODI1OGJjYzBlYmNmYmJiYzVjOWM3NDU1YmJmNTYwMDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X VEYvd3RmL1dlYWtQdHIuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9XZWFrUHRyLmgKQEAgLTM0LDcg KzM0LDYgQEAKIAogbmFtZXNwYWNlIFdURiB7CiAKLXRlbXBsYXRlPHR5cGVuYW1lIFQ+IGNsYXNz IFdlYWtQdHI7CiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBjbGFzcyBXZWFrUHRyRmFjdG9yeTsKIAog Ly8gTm90ZTogV2Vha1JlZmVyZW5jZSBpcyBhbiBpbXBsZW1lbnRhdGlvbiBkZXRhaWwsIGFuZCBz aG91bGQgbm90IGJlIHVzZWQgZGlyZWN0bHkuCkBAIC00MywxNiArNDIsMTUgQEAgY2xhc3MgV2Vh a1JlZmVyZW5jZSA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxXZWFrUmVmZXJlbmNlPFQ+ PiB7CiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoV2Vha1JlZmVyZW5jZTxUPik7CiAgICAgV1RG X01BS0VfRkFTVF9BTExPQ0FURUQ7CiBwdWJsaWM6CisgICAgc3RhdGljIFJlZjxXZWFrUmVmZXJl bmNlPFQ+PiBjcmVhdGUoVCogcHRyKSB7IHJldHVybiBhZG9wdFJlZigqbmV3IFdlYWtSZWZlcmVu Y2UocHRyKSk7IH0KKwogICAgIFQqIGdldCgpIGNvbnN0IHsgcmV0dXJuIG1fcHRyOyB9CiAKICAg ICB2b2lkIGNsZWFyKCkgeyBtX3B0ciA9IG51bGxwdHI7IH0KIAogcHJpdmF0ZToKLSAgICBmcmll bmQgY2xhc3MgV2Vha1B0cjxUPjsKICAgICBmcmllbmQgY2xhc3MgV2Vha1B0ckZhY3Rvcnk8VD47 CiAKLSAgICBzdGF0aWMgUmVmPFdlYWtSZWZlcmVuY2U8VD4+IGNyZWF0ZShUKiBwdHIpIHsgcmV0 dXJuIGFkb3B0UmVmKCpuZXcgV2Vha1JlZmVyZW5jZShwdHIpKTsgfQotCiAgICAgZXhwbGljaXQg V2Vha1JlZmVyZW5jZShUKiBwdHIpCiAgICAgICAgIDogbV9wdHIocHRyKQogICAgIHsKQEAgLTYx LDMwICs1OSwzMCBAQCBwcml2YXRlOgogICAgIFQqIG1fcHRyOwogfTsKIAotdGVtcGxhdGU8dHlw ZW5hbWUgVD4KK3RlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFUgPSBUPgogY2xhc3MgV2Vh a1B0ciB7CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiBwdWJsaWM6Ci0gICAgV2Vha1B0 cigpIDogbV9yZWYoV2Vha1JlZmVyZW5jZTxUPjo6Y3JlYXRlKG51bGxwdHIpKSB7IH0KLSAgICBX ZWFrUHRyKHN0ZDo6bnVsbHB0cl90KSA6IG1fcmVmKFdlYWtSZWZlcmVuY2U8VD46OmNyZWF0ZShu dWxscHRyKSkgeyB9CisgICAgV2Vha1B0cigpOiBtX3JlZihXZWFrUmVmZXJlbmNlPFU+OjpjcmVh dGUobnVsbHB0cikpIHsgfQorICAgIFdlYWtQdHIoc3RkOjpudWxscHRyX3QpIDogbV9yZWYoV2Vh a1JlZmVyZW5jZTxVPjo6Y3JlYXRlKG51bGxwdHIpKSB7IH0KICAgICBXZWFrUHRyKGNvbnN0IFdl YWtQdHImIG8pIDogbV9yZWYoby5tX3JlZi5jb3B5UmVmKCkpIHsgfQotICAgIHRlbXBsYXRlPHR5 cGVuYW1lIFU+IFdlYWtQdHIoY29uc3QgV2Vha1B0cjxVPiYgbykgOiBtX3JlZihvLm1fcmVmLmNv cHlSZWYoKSkgeyB9CiAKLSAgICBUKiBnZXQoKSBjb25zdCB7IHJldHVybiBtX3JlZi0+Z2V0KCk7 IH0KKyAgICBUKiBnZXQoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxUKj4obV9yZWYtPmdl dCgpKTsgfQogICAgIG9wZXJhdG9yIGJvb2woKSBjb25zdCB7IHJldHVybiBtX3JlZi0+Z2V0KCk7 IH0KIAogICAgIFdlYWtQdHImIG9wZXJhdG9yPShjb25zdCBXZWFrUHRyJiBvKSB7IG1fcmVmID0g by5tX3JlZi5jb3B5UmVmKCk7IHJldHVybiAqdGhpczsgfQotICAgIFdlYWtQdHImIG9wZXJhdG9y PShzdGQ6Om51bGxwdHJfdCkgeyBtX3JlZiA9IFdlYWtSZWZlcmVuY2U8VD46OmNyZWF0ZShudWxs cHRyKTsgcmV0dXJuICp0aGlzOyB9CisgICAgV2Vha1B0ciYgb3BlcmF0b3I9KHN0ZDo6bnVsbHB0 cl90KSB7IG1fcmVmID0gV2Vha1JlZmVyZW5jZTxVPjo6Y3JlYXRlKG51bGxwdHIpOyByZXR1cm4g KnRoaXM7IH0KIAotICAgIFQqIG9wZXJhdG9yLT4oKSBjb25zdCB7IHJldHVybiBtX3JlZi0+Z2V0 KCk7IH0KKyAgICBUKiBvcGVyYXRvci0+KCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8VCo+ KG1fcmVmLT5nZXQoKSk7IH0KIAotICAgIHZvaWQgY2xlYXIoKSB7IG1fcmVmID0gV2Vha1JlZmVy ZW5jZTxUPjo6Y3JlYXRlKG51bGxwdHIpOyB9CisgICAgdm9pZCBjbGVhcigpIHsgbV9yZWYgPSBX ZWFrUmVmZXJlbmNlPFU+OjpjcmVhdGUobnVsbHB0cik7IH0KIAogcHJpdmF0ZToKLSAgICBmcmll bmQgY2xhc3MgV2Vha1B0ckZhY3Rvcnk8VD47Ci0gICAgV2Vha1B0cihSZWY8V2Vha1JlZmVyZW5j ZTxUPj4mJiByZWYpIDogbV9yZWYoc3RkOjpmb3J3YXJkPFJlZjxXZWFrUmVmZXJlbmNlPFQ+Pj4o cmVmKSkgeyB9CisgICAgZnJpZW5kIGNsYXNzIFdlYWtQdHJGYWN0b3J5PFU+OworCisgICAgV2Vh a1B0cihSZWY8V2Vha1JlZmVyZW5jZTxVPj4mJiByZWYpIDogbV9yZWYoc3RkOjpmb3J3YXJkPFJl ZjxXZWFrUmVmZXJlbmNlPFU+Pj4ocmVmKSkgeyB9CiAKLSAgICBSZWY8V2Vha1JlZmVyZW5jZTxU Pj4gbV9yZWY7CisgICAgUmVmPFdlYWtSZWZlcmVuY2U8VT4+IG1fcmVmOwogfTsKIAogdGVtcGxh dGU8dHlwZW5hbWUgVD4KQEAgLTEwMCwxMiArOTgsMTMgQEAgcHVibGljOgogICAgICAgICBtX3Jl Zi0+Y2xlYXIoKTsKICAgICB9CiAKLSAgICBXZWFrUHRyPFQ+IGNyZWF0ZVdlYWtQdHIoVCYgcHRy KSBjb25zdAorICAgIHRlbXBsYXRlPHR5cGVuYW1lIFUgPSBUPgorICAgIFdlYWtQdHI8VSwgVD4g Y3JlYXRlV2Vha1B0cihUJiBwdHIpIGNvbnN0CiAgICAgewogICAgICAgICBpZiAoIW1fcmVmKQog ICAgICAgICAgICAgbV9yZWYgPSBXZWFrUmVmZXJlbmNlPFQ+OjpjcmVhdGUoJnB0cik7CiAgICAg ICAgIEFTU0VSVCgmcHRyID09IG1fcmVmLT5nZXQoKSk7Ci0gICAgICAgIHJldHVybiBXZWFrUHRy PFQ+KFJlZjxXZWFrUmVmZXJlbmNlPFQ+PigqbV9yZWYpKTsKKyAgICAgICAgcmV0dXJuIFdlYWtQ dHI8VSwgVD4oUmVmPFdlYWtSZWZlcmVuY2U8VD4+KCptX3JlZikpOwogICAgIH0KIAogICAgIHZv aWQgcmV2b2tlQWxsKCkKQEAgLTEyMSwzMiArMTIwLDMyIEBAIHByaXZhdGU6CiAgICAgbXV0YWJs ZSBSZWZQdHI8V2Vha1JlZmVyZW5jZTxUPj4gbV9yZWY7CiB9OwogCi10ZW1wbGF0ZTx0eXBlbmFt ZSBULCB0eXBlbmFtZSBVPiBpbmxpbmUgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFdlYWtQdHI8VD4m IGEsIGNvbnN0IFdlYWtQdHI8VT4mIGIpCit0ZW1wbGF0ZTx0eXBlbmFtZSBULCB0eXBlbmFtZSBV LCB0eXBlbmFtZSBWLCB0eXBlbmFtZSBXPiBpbmxpbmUgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFdl YWtQdHI8VCwgVj4mIGEsIGNvbnN0IFdlYWtQdHI8VSwgVz4mIGIpCiB7CiAgICAgcmV0dXJuIGEu Z2V0KCkgPT0gYi5nZXQoKTsKIH0KIAotdGVtcGxhdGU8dHlwZW5hbWUgVCwgdHlwZW5hbWUgVT4g aW5saW5lIGJvb2wgb3BlcmF0b3I9PShjb25zdCBXZWFrUHRyPFQ+JiBhLCBVKiBiKQordGVtcGxh dGU8dHlwZW5hbWUgVCwgdHlwZW5hbWUgVSwgdHlwZW5hbWUgVj4gaW5saW5lIGJvb2wgb3BlcmF0 b3I9PShjb25zdCBXZWFrUHRyPFQsIFY+JiBhLCBVKiBiKQogewogICAgIHJldHVybiBhLmdldCgp ID09IGI7CiB9CiAKLXRlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFU+IGlubGluZSBib29s IG9wZXJhdG9yPT0oVCogYSwgY29uc3QgV2Vha1B0cjxVPiYgYikKK3RlbXBsYXRlPHR5cGVuYW1l IFQsIHR5cGVuYW1lIFUsIHR5cGVuYW1lIFY+IGlubGluZSBib29sIG9wZXJhdG9yPT0oVCogYSwg Y29uc3QgV2Vha1B0cjxVLCBWPiYgYikKIHsKICAgICByZXR1cm4gYSA9PSBiLmdldCgpOwogfQog Ci10ZW1wbGF0ZTx0eXBlbmFtZSBULCB0eXBlbmFtZSBVPiBpbmxpbmUgYm9vbCBvcGVyYXRvciE9 KGNvbnN0IFdlYWtQdHI8VD4mIGEsIGNvbnN0IFdlYWtQdHI8VT4mIGIpCit0ZW1wbGF0ZTx0eXBl bmFtZSBULCB0eXBlbmFtZSBVLCB0eXBlbmFtZSBWLCB0eXBlbmFtZSBXPiBpbmxpbmUgYm9vbCBv cGVyYXRvciE9KGNvbnN0IFdlYWtQdHI8VCwgVj4mIGEsIGNvbnN0IFdlYWtQdHI8VSwgVz4mIGIp CiB7CiAgICAgcmV0dXJuIGEuZ2V0KCkgIT0gYi5nZXQoKTsKIH0KIAotdGVtcGxhdGU8dHlwZW5h bWUgVCwgdHlwZW5hbWUgVT4gaW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBXZWFrUHRyPFQ+ JiBhLCBVKiBiKQordGVtcGxhdGU8dHlwZW5hbWUgVCwgdHlwZW5hbWUgVSwgdHlwZW5hbWUgVj4g aW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBXZWFrUHRyPFQsIFY+JiBhLCBVKiBiKQogewog ICAgIHJldHVybiBhLmdldCgpICE9IGI7CiB9CiAKLXRlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVu YW1lIFU+IGlubGluZSBib29sIG9wZXJhdG9yIT0oVCogYSwgY29uc3QgV2Vha1B0cjxVPiYgYikK K3RlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFUsIHR5cGVuYW1lIFY+IGlubGluZSBib29s IG9wZXJhdG9yIT0oVCogYSwgY29uc3QgV2Vha1B0cjxVLCBWPiYgYikKIHsKICAgICByZXR1cm4g YSAhPSBiLmdldCgpOwogfQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hh bmdlTG9nCmluZGV4IGRlMTdkNTk4ZTE0M2ViNTZiZjkyNTQ4MDU3ZWJkOGQyYmZkZjAzZmIuLjVh MDMzNDA5MmUyOGM4ZGE1OWYxMjQ4OWFlNjkyNzg5M2E5MjBjY2MgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOCBAQAorMjAxNy0w OS0yNiAgSmlld2VuIFRhbiAgPGppZXdlbl90YW5AYXBwbGUuY29tPgorCisgICAgICAgIFdlYWtQ dHJGYWN0b3J5IHNob3VsZCBhbGxvdyBkb3duY2FzdGluZworICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc3Mzg5CisgICAgICAgIDxyZGFyOi8vcHJvYmxl bS8zNDYwNDE3ND4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dlYWtQdHIuY3BwOgorICAg ICAgICAoVGVzdFdlYktpdEFQSTo6QmFzZTo6Zm9vKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6 OkJhc2U6OmNyZWF0ZVdlYWtQdHIpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6RGVyaXZlZDo6 Zm9vKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDE3LTA5LTI1ICBQZXIg QXJuZSBWb2xsYW4gIDxwdm9sbGFuQGFwcGxlLmNvbT4KIAogICAgICAgICBbV2luXSBydW4tYXBp LXRlc3RzIGlzIGZhaWxpbmcuCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RX ZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv VGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGNlMTBiZTllMTYx MDVkNDMwODMxOTczZWIwMTY3YWQwNDBkMzE1NDEuLjIyMzc3Mzg4ZTEwNmFiYWRjODRmYjcyNjFh MjdlNDJiZGEzY2FmMjAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktp dEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv VGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0yMTYsNiArMjE2LDcg QEAKIAkJNTc5MDFGQjExQ0FGMTQyRDAwRUQ2NEY5IC8qIExvYWRJbnZhbGlkVVJMUmVxdWVzdC5o dG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDU3OTAxRkIwMUNBRjE0MUMwMEVENjRGOSAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QuaHRtbCAq LzsgfTsKIAkJNTc5N0ZFMzExRUIxNUE2ODAwQjJGNEEwIC8qIE5hdmlnYXRpb25DbGllbnREZWZh dWx0Q3J5cHRvLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDU3OTdGRTJGMUVCMTVBNUYwMEIyRjRBMCAvKiBOYXZpZ2F0aW9uQ2xpZW50RGVmYXVsdENy eXB0by5jcHAgKi87IH07CiAJCTU3OTdGRTMzMUVCMTVBQjEwMEIyRjRBMCAvKiBuYXZpZ2F0aW9u LWNsaWVudC1kZWZhdWx0LWNyeXB0by5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDU3OTdGRTMyMUVCMTVBODkwMEIyRjRBMCAvKiBuYXZp Z2F0aW9uLWNsaWVudC1kZWZhdWx0LWNyeXB0by5odG1sICovOyB9OworCQk1N0MzRkE2NTFGN0Iw QjQ4MDA5RDRCODAgLyogV2Vha1B0ci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSAxQ0I5QkMzNzFBNjc0ODIzMDBGRTU2NzggLyogV2Vha1B0ci5jcHAg Ki87IH07CiAJCTU3RjU2QTVDMUM3RjhDQzEwMEYzMUQ3RSAvKiBJc05hdmlnYXRpb25BY3Rpb25U cnVzdGVkLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNTdGNTZBNUIxQzdGOEE0MDAwRjMxRDdFIC8qIElzTmF2aWdhdGlvbkFjdGlvblRy dXN0ZWQuaHRtbCAqLzsgfTsKIAkJNUMwQkY4OEQxREQ1OTY0RDAwQjAwMzI4IC8qIE1lbW9yeVBy ZXNzdXJlSGFuZGxlci5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDVDMEJGODhDMURENTk1NzQwMEIwMDMyOCAvKiBNZW1vcnlQcmVzc3VyZUhhbmRsZXIu bW0gKi87IH07CiAJCTVDMEJGODkxMURENTk5QTkwMEIwMDMyOCAvKiBXZWJWaWV3Q2FuUGFzdGVa ZXJvUG5nLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g NUMwQkY4OEYxREQ1OTk5QjAwQjAwMzI4IC8qIFdlYlZpZXdDYW5QYXN0ZVplcm9QbmcubW0gKi87 IH07CkBAIC0zMTEwLDYgKzMxMTEsNyBAQAogCQkJCTdDODNGQzcxMUQ1NTM1QTgwMDFERkJDRCAv KiBWYXJpYW50LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdDODNERjRDMUQwQTU5MEMwMEZFQkNG MyAvKiBWZWN0b3IuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMzdDN0NDMkQxRUE0MTQ2QjAwN0JE OTU2IC8qIFdlYWtMaW5raW5nLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTU3QzNGQTY1MUY3QjBC NDgwMDlENEI4MCAvKiBXZWFrUHRyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdDODNERjYzMUQw QTU5MEMwMEZFQkNGMyAvKiBXVEZTdHJpbmcuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkpOwogCQkJ cnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CmRpZmYgLS1naXQgYS9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9XZWFrUHRyLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV1RGL1dlYWtQdHIuY3BwCmluZGV4IDljNWFjNTlhN2M5N2QwMTI5MTdkZGI3MzBm NTVkNzAyMWM3NTQ0ZjMuLmEzZmUxYmQzMTlmYWRiZTE1ODZjZTg4ODMyN2QxYzgyNjU5ZDk2NTIg MTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dlYWtQdHIuY3BwCisr KyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dlYWtQdHIuY3BwCkBAIC0xLDUgKzEs NSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTUtMjAxNyBBcHBsZSBJbmMuIEFsbCByaWdodHMg cmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTE4MCw1ICsxODAs NjAgQEAgVEVTVChXVEZfV2Vha1B0ciwgRm9yZ2V0KQogICAgIHdlYWtQdHI3ID0gbnVsbHB0cjsK ICAgICBFWFBFQ1RfTlVMTCh3ZWFrUHRyNy5nZXQoKSk7CiB9Ci0gICAgCisKK2NsYXNzIEJhc2Ug eworcHVibGljOgorICAgIGludCBmb28oKQorICAgIHsKKyAgICAgICAgcmV0dXJuIDA7CisgICAg fQorCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KKyAgICBXZWFrUHRyPFQsIEJhc2U+IGNyZWF0 ZVdlYWtQdHIoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fd2Vha1B0ckZhY3RvcnkuY3JlYXRl V2Vha1B0cjxUPigqdGhpcyk7CisgICAgfQorCitwcml2YXRlOgorICAgIFdlYWtQdHJGYWN0b3J5 PEJhc2U+IG1fd2Vha1B0ckZhY3Rvcnk7Cit9OworCitjbGFzcyBEZXJpdmVkIDogcHVibGljIEJh c2UgeworcHVibGljOgorICAgIGludCBmb28oKQorICAgIHsKKyAgICAgICAgcmV0dXJuIDE7Cisg ICAgfQorfTsKKworVEVTVChXVEZfV2Vha1B0ciwgRG93bmNhc3RpbmcpCit7CisgICAgaW50IGR1 bW15MCA9IDA7CisgICAgaW50IGR1bW15MSA9IDE7CisKKyAgICBXZWFrUHRyPEJhc2U+IGJhc2VX ZWFrUHRyOworICAgIFdlYWtQdHI8RGVyaXZlZCwgQmFzZT4gZGVyaXZlZFdlYWtQdHI7CisKKyAg ICB7CisgICAgICAgIERlcml2ZWQgb2JqZWN0OworICAgICAgICBEZXJpdmVkKiBkZXJpdmVkUHRy ID0gJm9iamVjdDsKKyAgICAgICAgQmFzZSogYmFzZVB0ciA9IHN0YXRpY19jYXN0PEJhc2UqPigm b2JqZWN0KTsKKworICAgICAgICBiYXNlV2Vha1B0ciA9IG9iamVjdC5jcmVhdGVXZWFrUHRyPEJh c2U+KCk7CisgICAgICAgIEVYUEVDVF9FUShiYXNlUHRyLT5mb28oKSwgZHVtbXkwKTsKKyAgICAg ICAgRVhQRUNUX0VRKGJhc2VXZWFrUHRyLT5mb28oKSwgYmFzZVB0ci0+Zm9vKCkpOworICAgICAg ICBFWFBFQ1RfRVEoYmFzZVdlYWtQdHIuZ2V0KCktPmZvbygpLCBiYXNlUHRyLT5mb28oKSk7CisK KyAgICAgICAgZGVyaXZlZFdlYWtQdHIgPSBvYmplY3QuY3JlYXRlV2Vha1B0cjxEZXJpdmVkPigp OworICAgICAgICBFWFBFQ1RfRVEoZGVyaXZlZFdlYWtQdHItPmZvbygpLCBkdW1teTEpOworICAg ICAgICBFWFBFQ1RfRVEoZGVyaXZlZFdlYWtQdHItPmZvbygpLCBkZXJpdmVkUHRyLT5mb28oKSk7 CisgICAgICAgIEVYUEVDVF9FUShkZXJpdmVkV2Vha1B0ci5nZXQoKS0+Zm9vKCksIGRlcml2ZWRQ dHItPmZvbygpKTsKKworICAgICAgICBFWFBFQ1RfRVEoYmFzZVdlYWtQdHIuZ2V0KCksIGRlcml2 ZWRXZWFrUHRyLmdldCgpKTsKKyAgICB9CisKKyAgICBFWFBFQ1RfTlVMTChiYXNlV2Vha1B0ci5n ZXQoKSk7CisgICAgRVhQRUNUX05VTEwoZGVyaXZlZFdlYWtQdHIuZ2V0KCkpOworfQorCiB9IC8v IG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJCg== 321989 2017-09-27 12:00:27 -0700 2017-09-28 14:31:43 -0700 First Solution bug-177389-20170927120027.patch text/plain 7139 jiewen_tan U3VidmVyc2lvbiBSZXZpc2lvbjogMjIyNDYwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDRiMGRmN2NjODJkMzg3NjFkOGE3MTE1 ZjExMmRmMTdkM2Q1YzRkMjYuLmVmNmQ4NWE3ZjViY2RkMmIzYjExZGIxM2Q2NTk5MTNlZjkyYmQy MDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTctMDktMjcgIEppZXdlbiBUYW4gIDxqaWV3ZW5f dGFuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWFrUHRyRmFjdG9yeSBzaG91bGQgYWxsb3cgZG93 bmNhc3RpbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE3NzM4OQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMzQ2MDQxNzQ+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSW4gdGhpcyBwYXRjaCwgV2Vha1B0 ckZhY3RvcnkgaXMgZW5oYW5jZWQgd2l0aCB0aGUgYWJpbGl0eSB0byBjcmVhdGUgV2Vha1B0cnMK KyAgICAgICAgb2YgaXRzIG93bmVyJ3Mgc3ViIGNsYXNzZXMgYW5kIGhhdmUgdGhlbSBwb2ludCB0 byB0aGUgc2FtZSBXZWFrUmVmZXJlbmNlLgorCisgICAgICAgICogd3RmL1dlYWtQdHIuaDoKKyAg ICAgICAgKFdURjo6V2Vha1B0cjo6V2Vha1B0cik6CisgICAgICAgIFdlIGNhbm5vdCBkZXRlcm1p bmUgdGhlIGJhc2UgY2xhc3Mgb2YgdHlwZSBULCB0aHVzIG5vIGZyaWVuZHMuIEl0IGlzIG1hZGUg cHVibGljCisgICAgICAgIHN1Y2ggdGhhdCBXZWFrUHRyRmFjdG9yeSB3aXRoIGEgYmFzZSBjbGFz cyB0eXBlIFUgY2FuIGNyZWF0ZSBhIGRlcml2ZWQgdHlwZSBUCisgICAgICAgIFdlYWtQdHIuCisg ICAgICAgIChXVEY6OldlYWtQdHJGYWN0b3J5OjpjcmVhdGVXZWFrUHRyIGNvbnN0KToKKwogMjAx Ny0wOS0yMyAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhhbGxhd2FAYXBwbGUuY29tPgogCiAg ICAgICAgIEltYWdlcyBtYXkgcmVuZGVyIHBhcnRpYWwgZnJhbWVzIGV2ZW4gYWZ0ZXIgbG9hZGlu ZyBhbGwgdGhlIGVuY29kZWQgZGF0YQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvV2Vha1B0 ci5oIGIvU291cmNlL1dURi93dGYvV2Vha1B0ci5oCmluZGV4IGJkMmY1NDQzZGU5MWEwODJmN2Fl ZjM0MjM1NTJmMTlkMTkyMGVkYTYuLjY2M2QwZGJlOTY3YThlOGZhZTY2ZWYxMjkxMzkzZGM5Mjhi Zjg1NmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1dlYWtQdHIuaAorKysgYi9Tb3VyY2Uv V1RGL3d0Zi9XZWFrUHRyLmgKQEAgLTY4LDcgKzY4LDcgQEAgcHVibGljOgogICAgIFdlYWtQdHIo KSA6IG1fcmVmKFdlYWtSZWZlcmVuY2U8VD46OmNyZWF0ZShudWxscHRyKSkgeyB9CiAgICAgV2Vh a1B0cihzdGQ6Om51bGxwdHJfdCkgOiBtX3JlZihXZWFrUmVmZXJlbmNlPFQ+OjpjcmVhdGUobnVs bHB0cikpIHsgfQogICAgIFdlYWtQdHIoY29uc3QgV2Vha1B0ciYgbykgOiBtX3JlZihvLm1fcmVm LmNvcHlSZWYoKSkgeyB9Ci0gICAgdGVtcGxhdGU8dHlwZW5hbWUgVT4gV2Vha1B0cihjb25zdCBX ZWFrUHRyPFU+JiBvKSA6IG1fcmVmKG8ubV9yZWYuY29weVJlZigpKSB7IH0KKyAgICBXZWFrUHRy KFJlZjxXZWFrUmVmZXJlbmNlPFQ+PiYmIHJlZikgOiBtX3JlZihzdGQ6OmZvcndhcmQ8UmVmPFdl YWtSZWZlcmVuY2U8VD4+PihyZWYpKSB7IH0KIAogICAgIFQqIGdldCgpIGNvbnN0IHsgcmV0dXJu IG1fcmVmLT5nZXQoKTsgfQogICAgIG9wZXJhdG9yIGJvb2woKSBjb25zdCB7IHJldHVybiBtX3Jl Zi0+Z2V0KCk7IH0KQEAgLTgxLDkgKzgxLDYgQEAgcHVibGljOgogICAgIHZvaWQgY2xlYXIoKSB7 IG1fcmVmID0gV2Vha1JlZmVyZW5jZTxUPjo6Y3JlYXRlKG51bGxwdHIpOyB9CiAKIHByaXZhdGU6 Ci0gICAgZnJpZW5kIGNsYXNzIFdlYWtQdHJGYWN0b3J5PFQ+OwotICAgIFdlYWtQdHIoUmVmPFdl YWtSZWZlcmVuY2U8VD4+JiYgcmVmKSA6IG1fcmVmKHN0ZDo6Zm9yd2FyZDxSZWY8V2Vha1JlZmVy ZW5jZTxUPj4+KHJlZikpIHsgfQotCiAgICAgUmVmPFdlYWtSZWZlcmVuY2U8VD4+IG1fcmVmOwog fTsKIApAQCAtMTAwLDEyICs5NywxNCBAQCBwdWJsaWM6CiAgICAgICAgIG1fcmVmLT5jbGVhcigp OwogICAgIH0KIAotICAgIFdlYWtQdHI8VD4gY3JlYXRlV2Vha1B0cihUJiBwdHIpIGNvbnN0Cisg ICAgdGVtcGxhdGU8dHlwZW5hbWUgVSA9IFQ+CisgICAgV2Vha1B0cjxVPiBjcmVhdGVXZWFrUHRy KFQmIHB0cikgY29uc3QKICAgICB7CiAgICAgICAgIGlmICghbV9yZWYpCiAgICAgICAgICAgICBt X3JlZiA9IFdlYWtSZWZlcmVuY2U8VD46OmNyZWF0ZSgmcHRyKTsKICAgICAgICAgQVNTRVJUKCZw dHIgPT0gbV9yZWYtPmdldCgpKTsKLSAgICAgICAgcmV0dXJuIFdlYWtQdHI8VD4oUmVmPFdlYWtS ZWZlcmVuY2U8VD4+KCptX3JlZikpOworICAgICAgICBzdGF0aWNfYXNzZXJ0KHN0ZDo6aXNfY29u dmVydGlibGU8VSosIFQqPjo6dmFsdWUsICJUKiBtdXN0IGJlIGNvbnZlcnRpYmxlIHRvIFUqIik7 CisgICAgICAgIHJldHVybiBXZWFrUHRyPFU+KFJlZjxXZWFrUmVmZXJlbmNlPFU+PihyZWludGVy cHJldF9jYXN0PFdlYWtSZWZlcmVuY2U8VT4mPigqbV9yZWYpKSk7CiAgICAgfQogCiAgICAgdm9p ZCByZXZva2VBbGwoKQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdl TG9nCmluZGV4IGRlMTdkNTk4ZTE0M2ViNTZiZjkyNTQ4MDU3ZWJkOGQyYmZkZjAzZmIuLjViM2Zk MzNhNDEyNDJlODQ5ZWMyMmZmOGE3MGQ5ZWEzYzk3ZjRhMjYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0No YW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOCBAQAorMjAxNy0wOS0y NyAgSmlld2VuIFRhbiAgPGppZXdlbl90YW5AYXBwbGUuY29tPgorCisgICAgICAgIFdlYWtQdHJG YWN0b3J5IHNob3VsZCBhbGxvdyBkb3duY2FzdGluZworICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc3Mzg5CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8z NDYwNDE3ND4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q OgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dlYWtQdHIuY3BwOgorICAgICAg ICAoVGVzdFdlYktpdEFQSTo6QmFzZTo6Zm9vKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OkJh c2U6OmNyZWF0ZVdlYWtQdHIpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6RGVyaXZlZDo6Zm9v KToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDE3LTA5LTI1ICBQZXIgQXJu ZSBWb2xsYW4gIDxwdm9sbGFuQGFwcGxlLmNvbT4KIAogICAgICAgICBbV2luXSBydW4tYXBpLXRl c3RzIGlzIGZhaWxpbmcuCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJL aXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGNlMTBiZTllMTYxMDVk NDMwODMxOTczZWIwMTY3YWQwNDBkMzE1NDEuLjBmNDY5YTg3NWFkNTUzMjI3NzQ0NDc4ZTI5ZjU4 YjcyYjhhZmFlMGUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQ SS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0yMTYsNiArMjE2LDcgQEAK IAkJNTc5MDFGQjExQ0FGMTQyRDAwRUQ2NEY5IC8qIExvYWRJbnZhbGlkVVJMUmVxdWVzdC5odG1s IGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDU3 OTAxRkIwMUNBRjE0MUMwMEVENjRGOSAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QuaHRtbCAqLzsg fTsKIAkJNTc5N0ZFMzExRUIxNUE2ODAwQjJGNEEwIC8qIE5hdmlnYXRpb25DbGllbnREZWZhdWx0 Q3J5cHRvLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDU3OTdGRTJGMUVCMTVBNUYwMEIyRjRBMCAvKiBOYXZpZ2F0aW9uQ2xpZW50RGVmYXVsdENyeXB0 by5jcHAgKi87IH07CiAJCTU3OTdGRTMzMUVCMTVBQjEwMEIyRjRBMCAvKiBuYXZpZ2F0aW9uLWNs aWVudC1kZWZhdWx0LWNyeXB0by5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDU3OTdGRTMyMUVCMTVBODkwMEIyRjRBMCAvKiBuYXZpZ2F0 aW9uLWNsaWVudC1kZWZhdWx0LWNyeXB0by5odG1sICovOyB9OworCQk1N0MzRkE2NjFGN0MyNDhG MDA5RDRCODAgLyogV2Vha1B0ci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSAxQ0I5QkMzNzFBNjc0ODIzMDBGRTU2NzggLyogV2Vha1B0ci5jcHAgKi87 IH07CiAJCTU3RjU2QTVDMUM3RjhDQzEwMEYzMUQ3RSAvKiBJc05hdmlnYXRpb25BY3Rpb25UcnVz dGVkLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gNTdGNTZBNUIxQzdGOEE0MDAwRjMxRDdFIC8qIElzTmF2aWdhdGlvbkFjdGlvblRydXN0 ZWQuaHRtbCAqLzsgfTsKIAkJNUMwQkY4OEQxREQ1OTY0RDAwQjAwMzI4IC8qIE1lbW9yeVByZXNz dXJlSGFuZGxlci5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDVDMEJGODhDMURENTk1NzQwMEIwMDMyOCAvKiBNZW1vcnlQcmVzc3VyZUhhbmRsZXIubW0g Ki87IH07CiAJCTVDMEJGODkxMURENTk5QTkwMEIwMDMyOCAvKiBXZWJWaWV3Q2FuUGFzdGVaZXJv UG5nLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNUMw QkY4OEYxREQ1OTk5QjAwQjAwMzI4IC8qIFdlYlZpZXdDYW5QYXN0ZVplcm9QbmcubW0gKi87IH07 CkBAIC0zMTEwLDYgKzMxMTEsNyBAQAogCQkJCTdDODNGQzcxMUQ1NTM1QTgwMDFERkJDRCAvKiBW YXJpYW50LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdDODNERjRDMUQwQTU5MEMwMEZFQkNGMyAv KiBWZWN0b3IuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMzdDN0NDMkQxRUE0MTQ2QjAwN0JEOTU2 IC8qIFdlYWtMaW5raW5nLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTU3QzNGQTY2MUY3QzI0OEYw MDlENEI4MCAvKiBXZWFrUHRyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdDODNERjYzMUQwQTU5 MEMwMEZFQkNGMyAvKiBXVEZTdHJpbmcuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkpOwogCQkJcnVu T25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CmRpZmYgLS1naXQgYS9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9XZWFrUHRyLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv VGVzdHMvV1RGL1dlYWtQdHIuY3BwCmluZGV4IDljNWFjNTlhN2M5N2QwMTI5MTdkZGI3MzBmNTVk NzAyMWM3NTQ0ZjMuLmNkNzRmYzM1MWI3NGY3ZjM1N2YyNTIxNDdkZWM0NWY3MTQwYzQxNDggMTAw NjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dlYWtQdHIuY3BwCisrKyBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1dlYWtQdHIuY3BwCkBAIC0xODAsNSArMTgw LDYwIEBAIFRFU1QoV1RGX1dlYWtQdHIsIEZvcmdldCkKICAgICB3ZWFrUHRyNyA9IG51bGxwdHI7 CiAgICAgRVhQRUNUX05VTEwod2Vha1B0cjcuZ2V0KCkpOwogfQotICAgIAorCitjbGFzcyBCYXNl IHsKK3B1YmxpYzoKKyAgICBpbnQgZm9vKCkKKyAgICB7CisgICAgICAgIHJldHVybiAwOworICAg IH0KKworICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+CisgICAgV2Vha1B0cjxUPiBjcmVhdGVXZWFr UHRyKCkKKyAgICB7CisgICAgICAgIHJldHVybiBtX3dlYWtQdHJGYWN0b3J5LmNyZWF0ZVdlYWtQ dHI8VD4oKnRoaXMpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBXZWFrUHRyRmFjdG9yeTxCYXNl PiBtX3dlYWtQdHJGYWN0b3J5OworfTsKKworY2xhc3MgRGVyaXZlZCA6IHB1YmxpYyBCYXNlIHsK K3B1YmxpYzoKKyAgICBpbnQgZm9vKCkKKyAgICB7CisgICAgICAgIHJldHVybiAxOworICAgIH0K K307CisKK1RFU1QoV1RGX1dlYWtQdHIsIERvd25jYXN0aW5nKQoreworICAgIGludCBkdW1teTAg PSAwOworICAgIGludCBkdW1teTEgPSAxOworCisgICAgV2Vha1B0cjxCYXNlPiBiYXNlV2Vha1B0 cjsKKyAgICBXZWFrUHRyPERlcml2ZWQ+IGRlcml2ZWRXZWFrUHRyOworCisgICAgeworICAgICAg ICBEZXJpdmVkIG9iamVjdDsKKyAgICAgICAgRGVyaXZlZCogZGVyaXZlZFB0ciA9ICZvYmplY3Q7 CisgICAgICAgIEJhc2UqIGJhc2VQdHIgPSBzdGF0aWNfY2FzdDxCYXNlKj4oJm9iamVjdCk7CisK KyAgICAgICAgYmFzZVdlYWtQdHIgPSBvYmplY3QuY3JlYXRlV2Vha1B0cjxCYXNlPigpOworICAg ICAgICBFWFBFQ1RfRVEoYmFzZVB0ci0+Zm9vKCksIGR1bW15MCk7CisgICAgICAgIEVYUEVDVF9F UShiYXNlV2Vha1B0ci0+Zm9vKCksIGJhc2VQdHItPmZvbygpKTsKKyAgICAgICAgRVhQRUNUX0VR KGJhc2VXZWFrUHRyLmdldCgpLT5mb28oKSwgYmFzZVB0ci0+Zm9vKCkpOworCisgICAgICAgIGRl cml2ZWRXZWFrUHRyID0gb2JqZWN0LmNyZWF0ZVdlYWtQdHI8RGVyaXZlZD4oKTsKKyAgICAgICAg RVhQRUNUX0VRKGRlcml2ZWRXZWFrUHRyLT5mb28oKSwgZHVtbXkxKTsKKyAgICAgICAgRVhQRUNU X0VRKGRlcml2ZWRXZWFrUHRyLT5mb28oKSwgZGVyaXZlZFB0ci0+Zm9vKCkpOworICAgICAgICBF WFBFQ1RfRVEoZGVyaXZlZFdlYWtQdHIuZ2V0KCktPmZvbygpLCBkZXJpdmVkUHRyLT5mb28oKSk7 CisKKyAgICAgICAgRVhQRUNUX0VRKGJhc2VXZWFrUHRyLmdldCgpLCBkZXJpdmVkV2Vha1B0ci5n ZXQoKSk7CisgICAgfQorCisgICAgRVhQRUNUX05VTEwoYmFzZVdlYWtQdHIuZ2V0KCkpOworICAg IEVYUEVDVF9OVUxMKGRlcml2ZWRXZWFrUHRyLmdldCgpKTsKK30KKwogfSAvLyBuYW1lc3BhY2Ug VGVzdFdlYktpdEFQSQo=