108892 2013-02-04 20:00:19 -0800 Passing alpha to DeferredImageDecoder once decoding completes 2013-02-14 11:47:49 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 0 qinmin webkit-unassigned cc-bugs dglazkov hclam jamesr levin+threading senorblanco tomhudson webkit.review.bot oldest_to_newest 825050 0 qinmin 2013-02-04 20:00:19 -0800 Passing alpha to DeferredImageDecoder once decoding completes 825690 1 186672 qinmin 2013-02-05 12:07:44 -0800 Created attachment 186672 Patch 825710 2 186672 webkit.review.bot 2013-02-05 12:33:38 -0800 Comment on attachment 186672 Patch Attachment 186672 did not pass cr-linux-debug-ews (chromium-xvfb): Output: http://queues.webkit.org/results/16373796 830267 3 186672 hclam 2013-02-11 15:58:22 -0800 Comment on attachment 186672 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=186672&action=review You don't need to change LazyDecodingPixel or ScaledImageFragment. Save the alpha state in ImageFrameGenerator instead. You will have to lock it when accessing this field. > Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.cpp:185 > + LazyDecodingPixelRef* pixelRef = static_cast<LazyDecodingPixelRef*>(m_lazyDecodedFrame.getSkBitmap().pixelRef()); alpha state should be saved in ImageFrameGenerator. ImageFrameGenerator corresponds to one image file. It exists regardless whether or not an image is cached or not. So in the case of ScaledImageFragment being evicted the code can return the correct alpha state regardless of whether it is cached or not. > Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.cpp:213 > + bool hasAlpha = (*decoder)->frameHasAlphaAtIndex(0); Do something like: m_hasAlpha = isComplete && !fullSizeBitmap.isOpaque(); 831035 4 186672 qinmin 2013-02-12 09:50:14 -0800 Comment on attachment 186672 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=186672&action=review >> Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.cpp:213 >> + bool hasAlpha = (*decoder)->frameHasAlphaAtIndex(0); > > Do something like: > > m_hasAlpha = isComplete && !fullSizeBitmap.isOpaque(); hmm.... if isComplete is false, shouldn't we return true there to force image decoding? 831039 5 186672 hclam 2013-02-12 09:55:39 -0800 Comment on attachment 186672 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=186672&action=review >>> Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.cpp:213 >>> + bool hasAlpha = (*decoder)->frameHasAlphaAtIndex(0); >> >> Do something like: >> >> m_hasAlpha = isComplete && !fullSizeBitmap.isOpaque(); > > hmm.... if isComplete is false, shouldn't we return true there to force image decoding? I don't know what you mean. Actually now I think about it again you can just do !fullSizeBitmap.isOpaque(). Don't call frameHasAlphaAtIndex(0) it might have side effect. 831040 6 186672 qinmin 2013-02-12 10:02:20 -0800 Comment on attachment 186672 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=186672&action=review >>>> Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.cpp:213 >>>> + bool hasAlpha = (*decoder)->frameHasAlphaAtIndex(0); >>> >>> Do something like: >>> >>> m_hasAlpha = isComplete && !fullSizeBitmap.isOpaque(); >> >> hmm.... if isComplete is false, shouldn't we return true there to force image decoding? > > I don't know what you mean. > > Actually now I think about it again you can just do !fullSizeBitmap.isOpaque(). Don't call frameHasAlphaAtIndex(0) it might have side effect. Yes, I think !fullSizeBitmap.isOpaque() should be correct. hasAlpha should be defaulted to true. So if isComplete is false, we should use true so that there are no optimization happening elsewhere. 831041 7 186672 hclam 2013-02-12 10:04:02 -0800 Comment on attachment 186672 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=186672&action=review >>>>> Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.cpp:213 >>>>> + bool hasAlpha = (*decoder)->frameHasAlphaAtIndex(0); >>>> >>>> Do something like: >>>> >>>> m_hasAlpha = isComplete && !fullSizeBitmap.isOpaque(); >>> >>> hmm.... if isComplete is false, shouldn't we return true there to force image decoding? >> >> I don't know what you mean. >> >> Actually now I think about it again you can just do !fullSizeBitmap.isOpaque(). Don't call frameHasAlphaAtIndex(0) it might have side effect. > > Yes, I think !fullSizeBitmap.isOpaque() should be correct. > hasAlpha should be defaulted to true. So if isComplete is false, we should use true so that there are no optimization happening elsewhere. isOpaque() is default to false, it is set to true only if decoder tells it to. So it's more accurate than mixing it with isComplete. For example progressive JPEG, an image can be partially decoded (i.e. isComplete == false) but it is opaque. 831081 8 187898 qinmin 2013-02-12 10:52:19 -0800 Created attachment 187898 Patch 831084 9 186672 qinmin 2013-02-12 10:52:47 -0800 Comment on attachment 186672 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=186672&action=review >> Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.cpp:185 >> + LazyDecodingPixelRef* pixelRef = static_cast<LazyDecodingPixelRef*>(m_lazyDecodedFrame.getSkBitmap().pixelRef()); > > alpha state should be saved in ImageFrameGenerator. > > ImageFrameGenerator corresponds to one image file. It exists regardless whether or not an image is cached or not. So in the case of ScaledImageFragment being evicted the code can return the correct alpha state regardless of whether it is cached or not. Done. >>>>>> Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.cpp:213 >>>>>> + bool hasAlpha = (*decoder)->frameHasAlphaAtIndex(0); >>>>> >>>>> Do something like: >>>>> >>>>> m_hasAlpha = isComplete && !fullSizeBitmap.isOpaque(); >>>> >>>> hmm.... if isComplete is false, shouldn't we return true there to force image decoding? >>> >>> I don't know what you mean. >>> >>> Actually now I think about it again you can just do !fullSizeBitmap.isOpaque(). Don't call frameHasAlphaAtIndex(0) it might have side effect. >> >> Yes, I think !fullSizeBitmap.isOpaque() should be correct. >> hasAlpha should be defaulted to true. So if isComplete is false, we should use true so that there are no optimization happening elsewhere. > > isOpaque() is default to false, it is set to true only if decoder tells it to. So it's more accurate than mixing it with isComplete. For example progressive JPEG, an image can be partially decoded (i.e. isComplete == false) but it is opaque. Done. 831611 10 187898 hclam 2013-02-12 21:34:43 -0800 Comment on attachment 187898 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=187898&action=review > Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.cpp:186 > + return pixelRef->frameGenerator()->hasAlpha(); DeferredImageDecoder already has a pointer to ImageFrameGenerator. > Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.h:70 > + bool hasAlpha() const { return m_hasAlpha; } This is not thread-safe and we need a lock for reading and writing to this value. You don't want to acquire the decodeMutex.. so I guess it's fine to have a alphaMutex (reluctantly..) 832259 11 188163 qinmin 2013-02-13 13:23:42 -0800 Created attachment 188163 Patch 832266 12 187898 qinmin 2013-02-13 13:26:25 -0800 Comment on attachment 187898 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=187898&action=review >> Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.cpp:186 >> + return pixelRef->frameGenerator()->hasAlpha(); > > DeferredImageDecoder already has a pointer to ImageFrameGenerator. Done. >> Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.h:70 >> + bool hasAlpha() const { return m_hasAlpha; } > > This is not thread-safe and we need a lock for reading and writing to this value. > > You don't want to acquire the decodeMutex.. so I guess it's fine to have a alphaMutex (reluctantly..) Good catch on thread safety. 832282 13 hclam 2013-02-13 13:33:54 -0800 Okay. LGTM. 832394 14 qinmin 2013-02-13 15:05:55 -0800 ping. Stephen, any thoughts on this. 832547 15 188163 senorblanco 2013-02-13 17:03:00 -0800 Comment on attachment 188163 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=188163&action=review OK. r=me > Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.cpp:227 > + MutexLocker lock(m_alphaMutex); > + return m_hasAlpha; I know I'll regret asking this, since threading has a long history of making me look like an idiot, but why do you need to lock the mutex for a read? It's a bool, so all reads should be atomic anyway, no? 832635 16 188163 qinmin 2013-02-13 18:18:48 -0800 Comment on attachment 188163 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=188163&action=review >> Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.cpp:227 >> + return m_hasAlpha; > > I know I'll regret asking this, since threading has a long history of making me look like an idiot, but why do you need to lock the mutex for a read? It's a bool, so all reads should be atomic anyway, no? reading a bool should be atomic, but I am not sure whether this is the case with multi-core processor cache. If read/write are on different processors, this probably might not hold. 832693 17 qinmin 2013-02-13 20:15:47 -0800 (In reply to comment #16) > (From update of attachment 188163 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=188163&action=review > > >> Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.cpp:227 > >> + return m_hasAlpha; > > > > I know I'll regret asking this, since threading has a long history of making me look like an idiot, but why do you need to lock the mutex for a read? It's a bool, so all reads should be atomic anyway, no? > > reading a bool should be atomic, but I am not sure whether this is the case with multi-core processor cache. > If read/write are on different processors, this probably might not hold. In addition to processor cache, there could be other factors that cause out-of-order execution: pipelining, cache, optimization etc. In such cases, when we set the boolean to false, the code before the set statement might not have been executed yet. 832905 18 188163 senorblanco 2013-02-14 03:39:20 -0800 Comment on attachment 188163 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=188163&action=review >>>> Source/WebCore/platform/graphics/chromium/ImageFrameGenerator.cpp:227 >>>> + return m_hasAlpha; >>> >>> I know I'll regret asking this, since threading has a long history of making me look like an idiot, but why do you need to lock the mutex for a read? It's a bool, so all reads should be atomic anyway, no? >> >> reading a bool should be atomic, but I am not sure whether this is the case with multi-core processor cache. >> If read/write are on different processors, this probably might not hold. > > In addition to processor cache, there could be other factors that cause out-of-order execution: pipelining, cache, optimization etc. In such cases, when we set the boolean to false, the code before the set statement might not have been executed yet. Looks like I was wrong in the general case anyway: although for the vast majority of CPU architectures, a single read or write of machine word or smaller is guaranteed atomic, this is still technically processor-specific, and not guaranteed by C++. However, I don't understand what you mean by "the code before the set statement might not have executed yet". Do you mean, the call to !fullSizeBitmap.isOpaque()? That seems to be the only thing that the mutex protects: that m_hasAlpha is set to the value of !fullSizeBitmap.isOpaque() atomically. The call to hasAlpha() could come in on another thread before or after that change to the value, and it might return true or false depending on thread ordering. The only thing the mutex ensures is that it won't occur during !fullSizeBitmap.isOpaque() or the assignment. If that's the intent, sorry for the tangent. 833114 19 qinmin 2013-02-14 08:48:36 -0800 In out-of-order execution, if you have some code like: do_sth_to_beta(); alpha=true; when alpha=true is executed, you cannot guarantee that do_sth_to_beta() is finished. And on another thread, if you have if(alpha) { beta=false; } This is problematic. Since do_sth_to_beta() could be still running, so setting beta to false will have an adverse effect on that call. (In reply to comment #18) > > Looks like I was wrong in the general case anyway: although for the vast majority of CPU architectures, a single read or write of machine word or smaller is guaranteed atomic, this is still technically processor-specific, and not guaranteed by C++. > > However, I don't understand what you mean by "the code before the set statement might not have executed yet". Do you mean, the call to !fullSizeBitmap.isOpaque()? That seems to be the only thing that the mutex protects: that m_hasAlpha is set to the value of !fullSizeBitmap.isOpaque() atomically. The call to hasAlpha() could come in on another thread before or after that change to the value, and it might return true or false depending on thread ordering. The only thing the mutex ensures is that it won't occur during !fullSizeBitmap.isOpaque() or the assignment. If that's the intent, sorry for the tangent. 833152 20 senorblanco 2013-02-14 09:34:01 -0800 (In reply to comment #19) > In out-of-order execution, if you have some code like: > > do_sth_to_beta(); > alpha=true; > > when alpha=true is executed, you cannot guarantee that do_sth_to_beta() is finished. I think you're confusing out-of-order execution with multithreading. Out-of-order execution only means that instructions can be reordered on the processor if they have no effect on apparent program order. I.e., you can hoist a read above an ALU op, as long as there are no data dependencies between them. The instructions are still retired in program order. Cache coherence ensures that this holds across processors as well. > And on another thread, if you have > > if(alpha) { > beta=false; > } > This is problematic. Since do_sth_to_beta() could be still running, so setting beta to false will have an adverse effect on that call. Right, that would be problematic, but that's not the case here: you only have the mutex protecting one write to the variable, and one read, not two writes. As I said before, I don't think the mutex protecting the read is doing anything, but that is processor-dependent and harmless I guess. Anyway, this is getting way off topic for the code review, and my r+ still stands. > > (In reply to comment #18) > > > > Looks like I was wrong in the general case anyway: although for the vast majority of CPU architectures, a single read or write of machine word or smaller is guaranteed atomic, this is still technically processor-specific, and not guaranteed by C++. > > > > However, I don't understand what you mean by "the code before the set statement might not have executed yet". Do you mean, the call to !fullSizeBitmap.isOpaque()? That seems to be the only thing that the mutex protects: that m_hasAlpha is set to the value of !fullSizeBitmap.isOpaque() atomically. The call to hasAlpha() could come in on another thread before or after that change to the value, and it might return true or false depending on thread ordering. The only thing the mutex ensures is that it won't occur during !fullSizeBitmap.isOpaque() or the assignment. If that's the intent, sorry for the tangent. 833231 21 hclam 2013-02-14 10:47:38 -0800 I love the fact that you guys are discussing locking, atomic read/write in this thread. :D 833236 22 188163 webkit.review.bot 2013-02-14 10:51:07 -0800 Comment on attachment 188163 Patch Clearing flags on attachment: 188163 Committed r142891: <http://trac.webkit.org/changeset/142891> 833237 23 webkit.review.bot 2013-02-14 10:51:11 -0800 All reviewed patches have been landed. Closing bug. 833242 24 tomhudson 2013-02-14 10:54:15 -0800 If there's some chance the mutex isn't necessary, I wish we hadn't landed this. 833248 25 qinmin 2013-02-14 11:01:54 -0800 (In reply to comment #24) > If there's some chance the mutex isn't necessary, I wish we hadn't landed this. I am wondering whether there will be a case that: if (decoder->frameHasAlphaAtIndex(0)) { read_pixelref(); } However, on another thread where alpha value just got set, the skbitmap still haven't been fully decoded yet. So we need a memory barrier there and Mutex should do that. 833249 26 hclam 2013-02-14 11:03:44 -0800 (In reply to comment #25) > (In reply to comment #24) > > If there's some chance the mutex isn't necessary, I wish we hadn't landed this. > > > I am wondering whether there will be a case that: > if (decoder->frameHasAlphaAtIndex(0)) { > read_pixelref(); > } > However, on another thread where alpha value just got set, the skbitmap still haven't been fully decoded yet. So we need a memory barrier there and Mutex should do that. That will not be the case. alpha value is known only after an image is fully decoded. 833251 27 qinmin 2013-02-14 11:10:40 -0800 (In reply to comment #26) > (In reply to comment #25) > > (In reply to comment #24) > > > If there's some chance the mutex isn't necessary, I wish we hadn't landed this. > > > > > > I am wondering whether there will be a case that: > > if (decoder->frameHasAlphaAtIndex(0)) { > > read_pixelref(); > > } > > However, on another thread where alpha value just got set, the skbitmap still haven't been fully decoded yet. So we need a memory barrier there and Mutex should do that. > > That will not be the case. alpha value is known only after an image is fully decoded. Would multi processor cache hurt? 833268 28 hclam 2013-02-14 11:27:14 -0800 (In reply to comment #27) > (In reply to comment #26) > > (In reply to comment #25) > > > (In reply to comment #24) > > > > If there's some chance the mutex isn't necessary, I wish we hadn't landed this. > > > > > > > > > I am wondering whether there will be a case that: > > > if (decoder->frameHasAlphaAtIndex(0)) { > > > read_pixelref(); > > > } > > > However, on another thread where alpha value just got set, the skbitmap still haven't been fully decoded yet. So we need a memory barrier there and Mutex should do that. > > > > That will not be the case. alpha value is known only after an image is fully decoded. > > Would multi processor cache hurt? I don't know what this means. But reading Stephen's comments that get me thinking that mutex might not be necessary. The value is either true or false and it doesn't hurt to have alpha == true. So even if we don't protect it and assignment comes while decode() is running the worst case is alpha is true when it should be false, which is benign anyway. 833278 29 qinmin 2013-02-14 11:45:16 -0800 (In reply to comment #28) > (In reply to comment #27) > > (In reply to comment #26) > > > (In reply to comment #25) > > > > (In reply to comment #24) > > > > > If there's some chance the mutex isn't necessary, I wish we hadn't landed this. > > > > > > > > > > > > I am wondering whether there will be a case that: > > > > if (decoder->frameHasAlphaAtIndex(0)) { > > > > read_pixelref(); > > > > } > > > > However, on another thread where alpha value just got set, the skbitmap still haven't been fully decoded yet. So we need a memory barrier there and Mutex should do that. > > > > > > That will not be the case. alpha value is known only after an image is fully decoded. > > > > Would multi processor cache hurt? > > I don't know what this means. > > But reading Stephen's comments that get me thinking that mutex might not be necessary. The value is either true or false and it doesn't hurt to have alpha == true. So even if we don't protect it and assignment comes while decode() is running the worst case is alpha is true when it should be false, which is benign anyway. Yes, for this case we are probably fine since the starting value is always true, and will only be changed to false later on. However, if there is a case that we can change the value from false to true, then it will be different. Processor A changes the value from false to true. At the same time processor B checks its own cache and sees that it is false, so it decides to do nothing. But since that is not going to happen, i think we are probably safe. 833281 30 hclam 2013-02-14 11:47:49 -0800 No, it won't change from false to true. 186672 2013-02-05 12:07:44 -0800 2013-02-12 10:52:47 -0800 Patch bug-108892-20130205120422.patch text/plain 13977 qinmin U3VidmVyc2lvbiBSZXZpc2lvbjogMTQxODc5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTdlM2MwNjcwODNmYzlk YWJmNDUxMzI3ZjNhMjQzZjM0NGJjMDdiYS4uY2UyZjM4YTVjNGQyOGY5ODI1YTBiNzE3NmEzYzJk YTMwZmU0OGQ5NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMxIEBACisyMDEzLTAyLTA1ICBNaW4g UWluICA8cWlubWluQGNocm9taXVtLm9yZz4KKworICAgICAgICBQYXNzaW5nIGFscGhhIHRvIERl ZmVycmVkSW1hZ2VEZWNvZGVyIG9uY2UgZGVjb2RpbmcgY29tcGxldGVzCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDg4OTIKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXZSBzaG91bGQgcGFzcyBoYXNBbHBo YSB2YWx1ZSBiYWNrIHRvIHRoZSBEZWZlcnJlZEltYWdlRGVjb2RlciBvbmNlIGRlY29kaW5nIGlz IGNvbXBsZXRlZAorICAgICAgICBBZGRlZCB1bml0IHRlc3RzIGluIEltYWdlRnJhbWVHZW5lcmF0 b3JUZXN0LgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRGVmZXJyZWRJ bWFnZURlY29kZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVmZXJyZWRJbWFnZURlY29kZXI6 OmZyYW1lSGFzQWxwaGFBdEluZGV4KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9JbWFnZUZyYW1lR2VuZXJhdG9yLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkltYWdlRnJh bWVHZW5lcmF0b3I6OnRyeVRvU2NhbGUpOgorICAgICAgICAoV2ViQ29yZTo6SW1hZ2VGcmFtZUdl bmVyYXRvcjo6ZGVjb2RlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXp5RGVjb2RpbmdQaXhlbFJlZi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXp5RGVjb2RpbmdQ aXhlbFJlZjo6TGF6eURlY29kaW5nUGl4ZWxSZWYpOgorICAgICAgICAoV2ViQ29yZTo6TGF6eURl Y29kaW5nUGl4ZWxSZWY6Om9uVW5sb2NrUGl4ZWxzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXp5RGVjb2RpbmdQaXhlbFJlZi5oOgorICAgICAgICAoV2ViQ29yZTo6 TGF6eURlY29kaW5nUGl4ZWxSZWY6Omhhc0FscGhhKToKKyAgICAgICAgKExhenlEZWNvZGluZ1Bp eGVsUmVmKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9TY2FsZWRJbWFn ZUZyYWdtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjYWxlZEltYWdlRnJhZ21lbnQ6OlNj YWxlZEltYWdlRnJhZ21lbnQpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L1NjYWxlZEltYWdlRnJhZ21lbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNjYWxlZEltYWdlRnJh Z21lbnQ6OmNyZWF0ZSk6CisgICAgICAgIChTY2FsZWRJbWFnZUZyYWdtZW50KToKKyAgICAgICAg KFdlYkNvcmU6OlNjYWxlZEltYWdlRnJhZ21lbnQ6Omhhc0FscGhhKToKKwogMjAxMy0wMi0wNSAg S2VudGFybyBIYXJhICA8aGFyYWtlbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdl ZCwgcm9sbGluZyBvdXQgcjE0MTg2NS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggYzYx ZTY5MGNjYjg5ODk0NGQxZmI0NDY4Yjk5YjM1ZTYxYTE4NjE0Ni4uMTM1Y2M3YjZkNDgzZmQ1YzA1 MmU4NmQ0MmE4ZjA5M2Y0ZmEzNmQ4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyMSBAQAorMjAxMy0wMi0wNSAgTWluIFFpbiAgPHFpbm1pbkBjaHJvbWl1bS5vcmc+CisK KyAgICAgICAgUGFzc2luZyBhbHBoYSB0byBEZWZlcnJlZEltYWdlRGVjb2RlciBvbmNlIGRlY29k aW5nIGNvbXBsZXRlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTA4ODkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgQWRkIHRlc3QgdG8gY2hlY2sgdGhhdCBhbHBoYSB2YWx1ZSBpcyBwYXNzZWQgZnJvbSB0 aGUgZGVjb2RlciB0byBJbWFnZUZyYW1lR2VuZXJhdG9yLgorCisgICAgICAgICogdGVzdHMvSW1h Z2VGcmFtZUdlbmVyYXRvclRlc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TW9ja0ltYWdlRGVj b2RlckZhY3Rvcnk6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpURVNUX0YpOgorICAgICAg ICAqIHRlc3RzL01vY2tJbWFnZURlY29kZXIuaDoKKyAgICAgICAgKFdlYkNvcmU6Ok1vY2tJbWFn ZURlY29kZXI6Ok1vY2tJbWFnZURlY29kZXIpOgorICAgICAgICAoV2ViQ29yZTo6TW9ja0ltYWdl RGVjb2Rlcjo6c2V0RnJhbWVIYXNBbHBoYSk6CisgICAgICAgIChNb2NrSW1hZ2VEZWNvZGVyKToK KyAgICAgICAgKFdlYkNvcmU6Ok1vY2tJbWFnZURlY29kZXI6OmZyYW1lSGFzQWxwaGFBdEluZGV4 KToKKwogMjAxMy0wMi0wNSAgS2VudGFybyBIYXJhICA8aGFyYWtlbkBjaHJvbWl1bS5vcmc+CiAK ICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjE0MTg2NS4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0RlZmVycmVkSW1hZ2VEZWNv ZGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0RlZmVy cmVkSW1hZ2VEZWNvZGVyLmNwcAppbmRleCAwNTBmNDM5ZTU5NmNiOTU1M2JhMWVkNzE1ZDg5Zjdi OTM4M2I5MmU5Li5kNmQzNmEwZGNmMjFiNzEzNmUzMWZjY2EwMzFhZDQxYWEzN2EzNWQ4IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9EZWZlcnJl ZEltYWdlRGVjb2Rlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vRGVmZXJyZWRJbWFnZURlY29kZXIuY3BwCkBAIC0xODEsMTAgKzE4MSwxMSBAQCB2 b2lkIERlZmVycmVkSW1hZ2VEZWNvZGVyOjpjbGVhckZyYW1lQnVmZmVyQ2FjaGUoc2l6ZV90IGNs ZWFyQmVmb3JlRnJhbWUpCiAKIGJvb2wgRGVmZXJyZWRJbWFnZURlY29kZXI6OmZyYW1lSGFzQWxw aGFBdEluZGV4KHNpemVfdCBpbmRleCkgY29uc3QKIHsKLSAgICAvLyBGSVhNRTogU3luY2hyb25p emUgdGhpcyBzdGF0ZSB3aXRoIEltYWdlRGVjb2RpbmdTdG9yZSB3aGVuIGltYWdlIGlzCi0gICAg Ly8gYWN0dWFsbHkgZGVjb2RlZC4gUmV0dXJuIHRydWUgaGVyZSBpcyBjb3JyZWN0IGluIHRlcm1z IG9mIHJlbmRlcmluZyBidXQKLSAgICAvLyBtYXkgbm90IGdvIHRocm91Z2ggc29tZSBvcHRpbWl6 ZWQgcmVuZGVyaW5nIGNvZGUgcGF0aC4KLSAgICByZXR1cm4gbV9hY3R1YWxEZWNvZGVyID8gbV9h Y3R1YWxEZWNvZGVyLT5mcmFtZUhhc0FscGhhQXRJbmRleChpbmRleCkgOiB0cnVlOworICAgIGlm ICghbV9hY3R1YWxEZWNvZGVyKSB7CisgICAgICAgIExhenlEZWNvZGluZ1BpeGVsUmVmKiBwaXhl bFJlZiA9IHN0YXRpY19jYXN0PExhenlEZWNvZGluZ1BpeGVsUmVmKj4obV9sYXp5RGVjb2RlZEZy YW1lLmdldFNrQml0bWFwKCkucGl4ZWxSZWYoKSk7CisgICAgICAgIHJldHVybiBwaXhlbFJlZi0+ aGFzQWxwaGEoKTsKKyAgICB9CisgICAgcmV0dXJuIG1fYWN0dWFsRGVjb2Rlci0+ZnJhbWVIYXNB bHBoYUF0SW5kZXgoaW5kZXgpOwogfQogCiB1bnNpZ25lZCBEZWZlcnJlZEltYWdlRGVjb2Rlcjo6 ZnJhbWVCeXRlc0F0SW5kZXgoc2l6ZV90IGluZGV4KSBjb25zdApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VGcmFtZUdlbmVyYXRvci5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9JbWFnZUZyYW1l R2VuZXJhdG9yLmNwcAppbmRleCA5M2Y5NWVmNDQxNzMzYWUzYmY5ZGEwYWU5Mjg4NjE0OWY0YWJk NDBhLi5lOTJjMjUyYjQ4MWVkNjE3ZmY1OGU5Y2E1ZWZjODNhYTgxMzY5NjBlIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9JbWFnZUZyYW1lR2Vu ZXJhdG9yLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9JbWFnZUZyYW1lR2VuZXJhdG9yLmNwcApAQCAtMTE5LDcgKzExOSw3IEBAIGNvbnN0IFNjYWxl ZEltYWdlRnJhZ21lbnQqIEltYWdlRnJhbWVHZW5lcmF0b3I6OnRyeVRvU2NhbGUoY29uc3QgU2Nh bGVkSW1hZ2VGcmFnCiAgICAgLy8gY2hlY2sgdGhlIHBpeGVscyBiZWZvcmUgdXNpbmcgaXQgbmV4 dCB0aW1lLgogICAgIFNrQml0bWFwIHNjYWxlZEJpdG1hcCA9IHNraWE6OkltYWdlT3BlcmF0aW9u czo6UmVzaXplKGZ1bGxTaXplSW1hZ2UtPmJpdG1hcCgpLCByZXNpemVNZXRob2QoKSwgc2NhbGVk U2l6ZS53aWR0aCgpLCBzY2FsZWRTaXplLmhlaWdodCgpLCAmYWxsb2NhdG9yKTsKIAotICAgIE93 blB0cjxTY2FsZWRJbWFnZUZyYWdtZW50PiBzY2FsZWRJbWFnZSA9IFNjYWxlZEltYWdlRnJhZ21l bnQ6OmNyZWF0ZShzY2FsZWRTaXplLCBzY2FsZWRCaXRtYXAsIGZ1bGxTaXplSW1hZ2UtPmlzQ29t cGxldGUoKSk7CisgICAgT3duUHRyPFNjYWxlZEltYWdlRnJhZ21lbnQ+IHNjYWxlZEltYWdlID0g U2NhbGVkSW1hZ2VGcmFnbWVudDo6Y3JlYXRlKHNjYWxlZFNpemUsIHNjYWxlZEJpdG1hcCwgZnVs bFNpemVJbWFnZS0+aXNDb21wbGV0ZSgpLCBmdWxsU2l6ZUltYWdlLT5oYXNBbHBoYSgpKTsKIAog ICAgIEltYWdlRGVjb2RpbmdTdG9yZTo6aW5zdGFuY2UoKS0+dW5sb2NrQ2FjaGUodGhpcywgZnVs bFNpemVJbWFnZSk7CiAKQEAgLTIxMCwxMCArMjEwLDExIEBAIFBhc3NPd25QdHI8U2NhbGVkSW1h Z2VGcmFnbWVudD4gSW1hZ2VGcmFtZUdlbmVyYXRvcjo6ZGVjb2RlKEltYWdlRGVjb2RlcioqIGRl Y29kCiAgICAgICAgIHJldHVybiBudWxscHRyOwogCiAgICAgYm9vbCBpc0NvbXBsZXRlID0gZnJh bWUtPnN0YXR1cygpID09IEltYWdlRnJhbWU6OkZyYW1lQ29tcGxldGU7CisgICAgYm9vbCBoYXNB bHBoYSA9ICgqZGVjb2RlciktPmZyYW1lSGFzQWxwaGFBdEluZGV4KDApOwogICAgIFNrQml0bWFw IGZ1bGxTaXplQml0bWFwID0gZnJhbWUtPmdldFNrQml0bWFwKCk7CiAgICAgQVNTRVJUKGZ1bGxT aXplQml0bWFwLndpZHRoKCkgPT0gbV9mdWxsU2l6ZS53aWR0aCgpICYmIGZ1bGxTaXplQml0bWFw LmhlaWdodCgpID09IG1fZnVsbFNpemUuaGVpZ2h0KCkpOwogCi0gICAgcmV0dXJuIFNjYWxlZElt YWdlRnJhZ21lbnQ6OmNyZWF0ZShtX2Z1bGxTaXplLCBmdWxsU2l6ZUJpdG1hcCwgaXNDb21wbGV0 ZSk7CisgICAgcmV0dXJuIFNjYWxlZEltYWdlRnJhZ21lbnQ6OmNyZWF0ZShtX2Z1bGxTaXplLCBm dWxsU2l6ZUJpdG1hcCwgaXNDb21wbGV0ZSwgaGFzQWxwaGEpOwogfQogCiB9IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9MYXp5RGVjb2RpbmdQaXhlbFJlZi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9MYXp5RGVjb2RpbmdQaXhlbFJlZi5jcHAKaW5kZXggMDAyNThj NjIxNDVmMTZkMjQ1YjU1OGY3NDJiNTJmODZjZGJlODNhZC4uMjNmYzUzZTdkZTZlZmFiZGFhZjk2 N2YwZjE5MjRkMTQ5MjgyMjEzZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vTGF6eURlY29kaW5nUGl4ZWxSZWYuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xhenlEZWNvZGluZ1BpeGVsUmVmLmNw cApAQCAtMzcsNiArMzcsNyBAQCBMYXp5RGVjb2RpbmdQaXhlbFJlZjo6TGF6eURlY29kaW5nUGl4 ZWxSZWYoUGFzc1JlZlB0cjxJbWFnZUZyYW1lR2VuZXJhdG9yPiBmcmFtZQogICAgIDogbV9mcmFt ZUdlbmVyYXRvcihmcmFtZUdlbmVyYXRvcikKICAgICAsIG1fc2NhbGVkU2l6ZShzY2FsZWRTaXpl KQogICAgICwgbV9zY2FsZWRTdWJzZXQoc2NhbGVkU3Vic2V0KQorICAgICwgbV9oYXNBbHBoYSh0 cnVlKQogICAgICwgbV9sb2NrZWRDYWNoZWRJbWFnZSgwKQogewogfQpAQCAtODAsNiArODEsNyBA QCB2b2lkIExhenlEZWNvZGluZ1BpeGVsUmVmOjpvblVubG9ja1BpeGVscygpCiB7CiAgICAgaWYg KG1fbG9ja2VkQ2FjaGVkSW1hZ2UpIHsKICAgICAgICAgSW1hZ2VEZWNvZGluZ1N0b3JlOjppbnN0 YW5jZSgpLT51bmxvY2tDYWNoZShtX2ZyYW1lR2VuZXJhdG9yLmdldCgpLCBtX2xvY2tlZENhY2hl ZEltYWdlKTsKKyAgICAgICAgbV9oYXNBbHBoYSA9IG1fbG9ja2VkQ2FjaGVkSW1hZ2UtPmhhc0Fs cGhhKCk7CiAgICAgICAgIG1fbG9ja2VkQ2FjaGVkSW1hZ2UgPSAwOwogICAgIH0KICAgICBtX211 dGV4LnVubG9jaygpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vTGF6eURlY29kaW5nUGl4ZWxSZWYuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL0xhenlEZWNvZGluZ1BpeGVsUmVmLmgKaW5kZXggMDllNmY4 ZDAzODQxYThhYjE1NjYwYWFkNjNiNWYxOGQwNzhjNGQyOC4uOTI3MDdjYjgyNTQ5NGJiOGYxYmJl YzI3MTUwZTA3ODJlNDhkNjgwMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vTGF6eURlY29kaW5nUGl4ZWxSZWYuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXp5RGVjb2RpbmdQaXhlbFJlZi5oCkBA IC01Niw2ICs1Niw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgYm9vbCBQcmVwYXJlVG9EZWNv ZGUoY29uc3QgTGF6eVBpeGVsUmVmOjpQcmVwYXJlUGFyYW1zJik7CiAgICAgdmlydHVhbCB2b2lk IERlY29kZSgpOworICAgIHZpcnR1YWwgYm9vbCBoYXNBbHBoYSgpIGNvbnN0IHsgcmV0dXJuIG1f aGFzQWxwaGE7IH0KIAogcHJvdGVjdGVkOgogICAgIC8vIFNrUGl4ZWxSZWYgaW1wbGVtZW50YXRp b24uCkBAIC02Nyw2ICs2OCw3IEBAIHByaXZhdGU6CiAgICAgUmVmUHRyPEltYWdlRnJhbWVHZW5l cmF0b3I+IG1fZnJhbWVHZW5lcmF0b3I7CiAgICAgU2tJU2l6ZSBtX3NjYWxlZFNpemU7CiAgICAg U2tJUmVjdCBtX3NjYWxlZFN1YnNldDsKKyAgICBib29sIG1faGFzQWxwaGE7CiAKICAgICBjb25z dCBTY2FsZWRJbWFnZUZyYWdtZW50KiBtX2xvY2tlZENhY2hlZEltYWdlOwogICAgIE11dGV4IG1f bXV0ZXg7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9TY2FsZWRJbWFnZUZyYWdtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1NjYWxlZEltYWdlRnJhZ21lbnQuY3BwCmluZGV4IDcxYmI2MjBhZWI0 NzY5NDU0YWY1NTJmYzY1OTVjYTg5N2I5ZDU0NTIuLjFlYTg4MGY4ZTUzYzJmMjJiYTM1OGZhNTVh ZTliN2E3MmQ4YjVlMzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1NjYWxlZEltYWdlRnJhZ21lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1NjYWxlZEltYWdlRnJhZ21lbnQuY3BwCkBAIC0z MywxMCArMzMsMTEgQEAgU2NhbGVkSW1hZ2VGcmFnbWVudDo6flNjYWxlZEltYWdlRnJhZ21lbnQo KQogewogfQogCi1TY2FsZWRJbWFnZUZyYWdtZW50OjpTY2FsZWRJbWFnZUZyYWdtZW50KGNvbnN0 IFNrSVNpemUmIHNjYWxlZFNpemUsIGNvbnN0IFNrQml0bWFwJiBiaXRtYXAsIGNvbnN0IGJvb2wg aXNDb21wbGV0ZSkKK1NjYWxlZEltYWdlRnJhZ21lbnQ6OlNjYWxlZEltYWdlRnJhZ21lbnQoY29u c3QgU2tJU2l6ZSYgc2NhbGVkU2l6ZSwgY29uc3QgU2tCaXRtYXAmIGJpdG1hcCwgYm9vbCBpc0Nv bXBsZXRlLCBib29sIGhhc0FscGhhKQogICAgIDogbV9zY2FsZWRTaXplKHNjYWxlZFNpemUpCiAg ICAgLCBtX2JpdG1hcChiaXRtYXApCiAgICAgLCBtX2lzQ29tcGxldGUoaXNDb21wbGV0ZSkKKyAg ICAsIG1faGFzQWxwaGEoaGFzQWxwaGEpCiB7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1NjYWxlZEltYWdlRnJhZ21lbnQuaCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1NjYWxlZEltYWdlRnJhZ21l bnQuaAppbmRleCAwMGEyMmI1MDA2YTkyOGZiYjMwOGM4N2I1YTBlM2Y2ZjJmY2YwNmU2Li40YzI2 NWJkNGM5MzU2MTNjYmU1NTk1NDM3YjEyMzYyMjE3YmI0YTM4IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9TY2FsZWRJbWFnZUZyYWdtZW50LmgK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vU2NhbGVkSW1h Z2VGcmFnbWVudC5oCkBAIC0zNywxMiArMzcsMTIgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogLy8g U2NhbGVkSW1hZ2VGcmFnbWVudCBpcyBhIHNjYWxlZCB2ZXJzaW9uIG9mIGFuIGltYWdlLgogY2xh c3MgU2NhbGVkSW1hZ2VGcmFnbWVudCB7CiBwdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NPd25QdHI8 U2NhbGVkSW1hZ2VGcmFnbWVudD4gY3JlYXRlKGNvbnN0IFNrSVNpemUmIHNjYWxlZFNpemUsIGNv bnN0IFNrQml0bWFwJiBiaXRtYXAsIGJvb2wgaXNDb21wbGV0ZSkKKyAgICBzdGF0aWMgUGFzc093 blB0cjxTY2FsZWRJbWFnZUZyYWdtZW50PiBjcmVhdGUoY29uc3QgU2tJU2l6ZSYgc2NhbGVkU2l6 ZSwgY29uc3QgU2tCaXRtYXAmIGJpdG1hcCwgYm9vbCBpc0NvbXBsZXRlLCBib29sIGhhc0FscGhh ID0gdHJ1ZSkKICAgICB7Ci0gICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgU2NhbGVkSW1hZ2VG cmFnbWVudChzY2FsZWRTaXplLCBiaXRtYXAsIGlzQ29tcGxldGUpKTsKKyAgICAgICAgcmV0dXJu IGFkb3B0UHRyKG5ldyBTY2FsZWRJbWFnZUZyYWdtZW50KHNjYWxlZFNpemUsIGJpdG1hcCwgaXND b21wbGV0ZSwgaGFzQWxwaGEpKTsKICAgICB9CiAKLSAgICBTY2FsZWRJbWFnZUZyYWdtZW50KGNv bnN0IFNrSVNpemUmLCBjb25zdCBTa0JpdG1hcCYsIGJvb2wgaXNDb21wbGV0ZSk7CisgICAgU2Nh bGVkSW1hZ2VGcmFnbWVudChjb25zdCBTa0lTaXplJiwgY29uc3QgU2tCaXRtYXAmLCBib29sIGlz Q29tcGxldGUsIGJvb2wgaGFzQWxwaGEpOwogICAgIH5TY2FsZWRJbWFnZUZyYWdtZW50KCk7CiAK ICAgICBjb25zdCBTa0lTaXplJiBzY2FsZWRTaXplKCkgY29uc3QgeyByZXR1cm4gbV9zY2FsZWRT aXplOyB9CkBAIC01MCwxMSArNTAsMTMgQEAgcHVibGljOgogICAgIFNrQml0bWFwJiBiaXRtYXAo KSB7IHJldHVybiBtX2JpdG1hcDsgfQogICAgIGJvb2wgaXNDb21wbGV0ZSgpIGNvbnN0IHsgcmV0 dXJuIG1faXNDb21wbGV0ZTsgfQogICAgIHZvaWQgc2V0SXNDb21wbGV0ZSgpIHsgbV9pc0NvbXBs ZXRlID0gdHJ1ZTsgfQorICAgIGJvb2wgaGFzQWxwaGEoKSBjb25zdCB7IHJldHVybiBtX2hhc0Fs cGhhOyB9CiAKIHByaXZhdGU6CiAgICAgU2tJU2l6ZSBtX3NjYWxlZFNpemU7CiAgICAgU2tCaXRt YXAgbV9iaXRtYXA7CiAgICAgYm9vbCBtX2lzQ29tcGxldGU7CisgICAgYm9vbCBtX2hhc0FscGhh OwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS90ZXN0cy9JbWFnZUZyYW1lR2VuZXJhdG9yVGVzdC5jcHAgYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3Rlc3RzL0ltYWdlRnJhbWVHZW5lcmF0b3JUZXN0LmNwcAppbmRleCBiNDE2 OWExMzliYWUzYjYzOTk3YzE0YTBjZTg0NDg0YjVlOWI1MTE2Li4yZDI4MmZhYjAxYzVlNmZjNmIw NjNiN2M0YjdiZDQ5Y2Q1ZjdlMDgyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3Rlc3RzL0ltYWdlRnJhbWVHZW5lcmF0b3JUZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3Rlc3RzL0ltYWdlRnJhbWVHZW5lcmF0b3JUZXN0LmNwcApAQCAtMTI0LDYgKzEyNCw3 IEBAIFBhc3NPd25QdHI8SW1hZ2VEZWNvZGVyPiBNb2NrSW1hZ2VEZWNvZGVyRmFjdG9yeTo6Y3Jl YXRlKCkKIHsKICAgICBPd25QdHI8TW9ja0ltYWdlRGVjb2Rlcj4gZGVjb2RlciA9IE1vY2tJbWFn ZURlY29kZXI6OmNyZWF0ZShtX3Rlc3QpOwogICAgIGRlY29kZXItPnNldFNpemUoZnVsbFNpemUo KS53aWR0aCgpLCBmdWxsU2l6ZSgpLmhlaWdodCgpKTsKKyAgICBkZWNvZGVyLT5zZXRGcmFtZUhh c0FscGhhKGZhbHNlKTsKICAgICByZXR1cm4gZGVjb2Rlci5yZWxlYXNlKCk7CiB9CiAKQEAgLTEz Nyw2ICsxMzgsNyBAQCBURVNUX0YoSW1hZ2VGcmFtZUdlbmVyYXRvclRlc3QsIGNhY2hlSGl0KQog ICAgIGNvbnN0IFNjYWxlZEltYWdlRnJhZ21lbnQqIHRlbXBJbWFnZSA9IG1fZ2VuZXJhdG9yLT5k ZWNvZGVBbmRTY2FsZShmdWxsU2l6ZSgpKTsKICAgICBFWFBFQ1RfRVEoZnVsbEltYWdlLCB0ZW1w SW1hZ2UpOwogICAgIEVYUEVDVF9FUShmdWxsU2l6ZSgpLCB0ZW1wSW1hZ2UtPnNjYWxlZFNpemUo KSk7CisgICAgRVhQRUNUX1RSVUUodGVtcEltYWdlLT5oYXNBbHBoYSgpKTsKICAgICBJbWFnZURl Y29kaW5nU3RvcmU6Omluc3RhbmNlKCktPnVubG9ja0NhY2hlKG1fZ2VuZXJhdG9yLmdldCgpLCB0 ZW1wSW1hZ2UpOwogICAgIEVYUEVDVF9FUSgwLCBtX2ZyYW1lQnVmZmVyUmVxdWVzdENvdW50KTsK IH0KQEAgLTE1MiwxMiArMTU0LDE0IEBAIFRFU1RfRihJbWFnZUZyYW1lR2VuZXJhdG9yVGVzdCwg Y2FjaGVNaXNzV2l0aFNjYWxlKQogICAgIGNvbnN0IFNjYWxlZEltYWdlRnJhZ21lbnQqIHNjYWxl ZEltYWdlID0gbV9nZW5lcmF0b3ItPmRlY29kZUFuZFNjYWxlKHNjYWxlZFNpemUoKSk7CiAgICAg RVhQRUNUX05FKGZ1bGxJbWFnZSwgc2NhbGVkSW1hZ2UpOwogICAgIEVYUEVDVF9FUShzY2FsZWRT aXplKCksIHNjYWxlZEltYWdlLT5zY2FsZWRTaXplKCkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBz Y2FsZWRJbWFnZS0+aGFzQWxwaGEoKSk7CiAgICAgSW1hZ2VEZWNvZGluZ1N0b3JlOjppbnN0YW5j ZSgpLT51bmxvY2tDYWNoZShtX2dlbmVyYXRvci5nZXQoKSwgc2NhbGVkSW1hZ2UpOwogCiAgICAg Ly8gQ2FjaGUgaGl0LgogICAgIGNvbnN0IFNjYWxlZEltYWdlRnJhZ21lbnQqIHRlbXBJbWFnZSA9 IG1fZ2VuZXJhdG9yLT5kZWNvZGVBbmRTY2FsZShzY2FsZWRTaXplKCkpOwogICAgIEVYUEVDVF9F UShzY2FsZWRJbWFnZSwgdGVtcEltYWdlKTsKICAgICBFWFBFQ1RfRVEoc2NhbGVkU2l6ZSgpLCB0 ZW1wSW1hZ2UtPnNjYWxlZFNpemUoKSk7CisgICAgRVhQRUNUX1RSVUUoc2NhbGVkSW1hZ2UtPmhh c0FscGhhKCkpOwogICAgIEltYWdlRGVjb2RpbmdTdG9yZTo6aW5zdGFuY2UoKS0+dW5sb2NrQ2Fj aGUobV9nZW5lcmF0b3IuZ2V0KCksIHRlbXBJbWFnZSk7CiAgICAgRVhQRUNUX0VRKDAsIG1fZnJh bWVCdWZmZXJSZXF1ZXN0Q291bnQpOwogfQpAQCAtMTcwLDYgKzE3NCw3IEBAIFRFU1RfRihJbWFn ZUZyYW1lR2VuZXJhdG9yVGVzdCwgY2FjaGVNaXNzV2l0aERlY29kZUFuZFNjYWxlKQogICAgIGNv bnN0IFNjYWxlZEltYWdlRnJhZ21lbnQqIHNjYWxlZEltYWdlID0gbV9nZW5lcmF0b3ItPmRlY29k ZUFuZFNjYWxlKHNjYWxlZFNpemUoKSk7CiAgICAgRVhQRUNUX0VRKDEsIG1fZnJhbWVCdWZmZXJS ZXF1ZXN0Q291bnQpOwogICAgIEVYUEVDVF9FUShzY2FsZWRTaXplKCksIHNjYWxlZEltYWdlLT5z Y2FsZWRTaXplKCkpOworICAgIEVYUEVDVF9GQUxTRShzY2FsZWRJbWFnZS0+aGFzQWxwaGEoKSk7 CiAgICAgSW1hZ2VEZWNvZGluZ1N0b3JlOjppbnN0YW5jZSgpLT51bmxvY2tDYWNoZShtX2dlbmVy YXRvci5nZXQoKSwgc2NhbGVkSW1hZ2UpOwogICAgIEVYUEVDVF9FUSgxLCBtX2RlY29kZXJzRGVz dHJveWVkKTsKIApAQCAtMTc3LDEyICsxODIsMTQgQEAgVEVTVF9GKEltYWdlRnJhbWVHZW5lcmF0 b3JUZXN0LCBjYWNoZU1pc3NXaXRoRGVjb2RlQW5kU2NhbGUpCiAgICAgY29uc3QgU2NhbGVkSW1h Z2VGcmFnbWVudCogZnVsbEltYWdlID0gbV9nZW5lcmF0b3ItPmRlY29kZUFuZFNjYWxlKGZ1bGxT aXplKCkpOwogICAgIEVYUEVDVF9ORShzY2FsZWRJbWFnZSwgZnVsbEltYWdlKTsKICAgICBFWFBF Q1RfRVEoZnVsbFNpemUoKSwgZnVsbEltYWdlLT5zY2FsZWRTaXplKCkpOworICAgIEVYUEVDVF9G QUxTRShmdWxsSW1hZ2UtPmhhc0FscGhhKCkpOwogICAgIEltYWdlRGVjb2RpbmdTdG9yZTo6aW5z dGFuY2UoKS0+dW5sb2NrQ2FjaGUobV9nZW5lcmF0b3IuZ2V0KCksIGZ1bGxJbWFnZSk7CiAKICAg ICAvLyBDYWNoZSBoaXQuCiAgICAgY29uc3QgU2NhbGVkSW1hZ2VGcmFnbWVudCogdGVtcEltYWdl ID0gbV9nZW5lcmF0b3ItPmRlY29kZUFuZFNjYWxlKHNjYWxlZFNpemUoKSk7CiAgICAgRVhQRUNU X0VRKHNjYWxlZEltYWdlLCB0ZW1wSW1hZ2UpOwogICAgIEVYUEVDVF9FUShzY2FsZWRTaXplKCks IHRlbXBJbWFnZS0+c2NhbGVkU2l6ZSgpKTsKKyAgICBFWFBFQ1RfRkFMU0UodGVtcEltYWdlLT5o YXNBbHBoYSgpKTsKICAgICBJbWFnZURlY29kaW5nU3RvcmU6Omluc3RhbmNlKCktPnVubG9ja0Nh Y2hlKG1fZ2VuZXJhdG9yLmdldCgpLCB0ZW1wSW1hZ2UpOwogICAgIEVYUEVDVF9FUSgxLCBtX2Zy YW1lQnVmZmVyUmVxdWVzdENvdW50KTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vdGVzdHMvTW9ja0ltYWdlRGVjb2Rlci5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90 ZXN0cy9Nb2NrSW1hZ2VEZWNvZGVyLmgKaW5kZXggNWM5YTYyMzdiOTRmODViYTNmZDYyNGJiYjU1 YTcwMjlhZDg5Zjg0MS4uMmZjNTcyMWVhMmVhM2EyZDA4ZmExYWUwNjZjNzAyZTZiNjEzZTU5NSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9Nb2NrSW1hZ2VEZWNvZGVy LmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9Nb2NrSW1hZ2VEZWNvZGVyLmgK QEAgLTQzLDYgKzQzLDcgQEAgcHVibGljOgogICAgIE1vY2tJbWFnZURlY29kZXIoTW9ja0ltYWdl RGVjb2RlckNsaWVudCogY2xpZW50KQogICAgICAgICA6IEltYWdlRGVjb2RlcihJbWFnZVNvdXJj ZTo6QWxwaGFQcmVtdWx0aXBsaWVkLCBJbWFnZVNvdXJjZTo6R2FtbWFBbmRDb2xvclByb2ZpbGVB cHBsaWVkKQogICAgICAgICAsIG1fZnJhbWVCdWZmZXJSZXF1ZXN0Q291bnQoMCkKKyAgICAgICAg LCBtX2ZyYW1lSGFzQWxwaGEodHJ1ZSkKICAgICAgICAgLCBtX2NsaWVudChjbGllbnQpCiAgICAg eyB9CiAKQEAgLTU5LDYgKzYwLDggQEAgcHVibGljOgogICAgICAgICByZXR1cm4gdHJ1ZTsKICAg ICB9CiAKKyAgICB2aXJ0dWFsIHZvaWQgc2V0RnJhbWVIYXNBbHBoYShib29sIGhhc0FscGhhKSB7 IG1fZnJhbWVIYXNBbHBoYSA9IGhhc0FscGhhOyB9CisKICAgICB2aXJ0dWFsIFN0cmluZyBmaWxl bmFtZUV4dGVuc2lvbigpIGNvbnN0CiAgICAgewogICAgICAgICByZXR1cm4gIm1vY2siOwpAQCAt NzUsOCArNzgsMTAgQEAgcHVibGljOgogCiAgICAgaW50IGZyYW1lQnVmZmVyUmVxdWVzdENvdW50 KCkgY29uc3QgeyByZXR1cm4gbV9mcmFtZUJ1ZmZlclJlcXVlc3RDb3VudDsgfQogCisgICAgYm9v bCBmcmFtZUhhc0FscGhhQXRJbmRleChzaXplX3QpIGNvbnN0IHsgcmV0dXJuIG1fZnJhbWVIYXNB bHBoYTsgfQogcHJpdmF0ZToKICAgICBpbnQgbV9mcmFtZUJ1ZmZlclJlcXVlc3RDb3VudDsKKyAg ICBib29sIG1fZnJhbWVIYXNBbHBoYTsKICAgICBNb2NrSW1hZ2VEZWNvZGVyQ2xpZW50KiBtX2Ns aWVudDsKIH07CiAK 187898 2013-02-12 10:52:19 -0800 2013-02-13 13:26:25 -0800 Patch bug-108892-20130212104848.patch text/plain 9159 qinmin U3VidmVyc2lvbiBSZXZpc2lvbjogMTQyNDI2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2QwOGRkNmM3OWUyOTYw ZDBjMWQyYzdkMjM2OGZlNzRiMmViMGM4Mi4uOGIwZmY0ODU0NWU0YjEzYTAyNDM4NjllZDU1YmM2 MTNjN2QyMTcxYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEzLTAyLTEyICBNaW4g UWluICA8cWlubWluQGNocm9taXVtLm9yZz4KKworICAgICAgICBQYXNzaW5nIGFscGhhIHRvIERl ZmVycmVkSW1hZ2VEZWNvZGVyIG9uY2UgZGVjb2RpbmcgY29tcGxldGVzCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDg4OTIKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXZSBzaG91bGQgcGFzcyBoYXNBbHBo YSB2YWx1ZSBiYWNrIHRvIHRoZSBEZWZlcnJlZEltYWdlRGVjb2RlciBvbmNlIGRlY29kaW5nIGlz IGNvbXBsZXRlZAorICAgICAgICBBZGRlZCB1bml0IHRlc3RzIGluIEltYWdlRnJhbWVHZW5lcmF0 b3JUZXN0LgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRGVmZXJyZWRJ bWFnZURlY29kZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVmZXJyZWRJbWFnZURlY29kZXI6 OmZyYW1lSGFzQWxwaGFBdEluZGV4KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9JbWFnZUZyYW1lR2VuZXJhdG9yLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkltYWdlRnJh bWVHZW5lcmF0b3I6OkltYWdlRnJhbWVHZW5lcmF0b3IpOgorICAgICAgICAoV2ViQ29yZTo6SW1h Z2VGcmFtZUdlbmVyYXRvcjo6ZGVjb2RlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9JbWFnZUZyYW1lR2VuZXJhdG9yLmg6CisgICAgICAgIChXZWJDb3JlOjpJbWFnZUZy YW1lR2VuZXJhdG9yOjpoYXNBbHBoYSk6CisgICAgICAgIChJbWFnZUZyYW1lR2VuZXJhdG9yKToK KwogMjAxMy0wMi0wNiAgS2VudGFybyBIYXJhICA8aGFyYWtlbkBjaHJvbWl1bS5vcmc+CiAKICAg ICAgICAgW1Y4XSBSZW5hbWUgaXNvbGF0ZWQoKSB0byBnZXRXb3JsZCgpLCByZW5hbWUgd29ybGRG b3JFbnRlcmVkQ29udGV4dElmSXNvbGF0ZWQoKSB0byB3b3JsZEZvckVudGVyZWRDb250ZXh0KCkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMzVhMGE3ZGY0MGIzNDIzYTQ0N2ZlODA3ZDM4 MmZlMTU1ODRhZjk0OS4uMTk4YTU4YTVjNDQzZWI2YmM1MGVhZDQwMWI3NjkwNDg4YTdlMDIzMSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMy0wMi0xMiAg TWluIFFpbiAgPHFpbm1pbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUGFzc2luZyBhbHBoYSB0 byBEZWZlcnJlZEltYWdlRGVjb2RlciBvbmNlIGRlY29kaW5nIGNvbXBsZXRlcworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTA4ODkyCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIHRlc3QgdG8gY2hlY2sg dGhhdCBhbHBoYSB2YWx1ZSBpcyBwYXNzZWQgZnJvbSB0aGUgZGVjb2RlciB0byBJbWFnZUZyYW1l R2VuZXJhdG9yLgorCisgICAgICAgICogdGVzdHMvSW1hZ2VGcmFtZUdlbmVyYXRvclRlc3QuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6TW9ja0ltYWdlRGVjb2RlckZhY3Rvcnk6OmNyZWF0ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpURVNUX0YpOgorICAgICAgICAqIHRlc3RzL01vY2tJbWFnZURlY29k ZXIuaDoKKyAgICAgICAgKFdlYkNvcmU6Ok1vY2tJbWFnZURlY29kZXI6OnNldEZyYW1lSGFzQWxw aGEpOgorICAgICAgICAoTW9ja0ltYWdlRGVjb2Rlcik6CisKIDIwMTMtMDItMTAgIEphbWVzIFJv Ymluc29uICA8amFtZXNyQGNocm9taXVtLm9yZz4KIAogICAgICAgICBbY2hyb21pdW1dIEVuYWJs ZSBtb3JlIG9mIHdlYmtpdF91bml0X3Rlc3RzIGluIGNvbXBvbmVudCBidWlsZHMKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0RlZmVycmVkSW1h Z2VEZWNvZGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0RlZmVycmVkSW1hZ2VEZWNvZGVyLmNwcAppbmRleCAwNTBmNDM5ZTU5NmNiOTU1M2JhMWVkNzE1 ZDg5ZjdiOTM4M2I5MmU5Li42MDM0NjNhMmIxMGZhZjUwZmZhMjk1NTZhNzk4OTBjYzc5Y2E3ZGRj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9E ZWZlcnJlZEltYWdlRGVjb2Rlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vRGVmZXJyZWRJbWFnZURlY29kZXIuY3BwCkBAIC0xODEsMTAgKzE4MSwx MSBAQCB2b2lkIERlZmVycmVkSW1hZ2VEZWNvZGVyOjpjbGVhckZyYW1lQnVmZmVyQ2FjaGUoc2l6 ZV90IGNsZWFyQmVmb3JlRnJhbWUpCiAKIGJvb2wgRGVmZXJyZWRJbWFnZURlY29kZXI6OmZyYW1l SGFzQWxwaGFBdEluZGV4KHNpemVfdCBpbmRleCkgY29uc3QKIHsKLSAgICAvLyBGSVhNRTogU3lu Y2hyb25pemUgdGhpcyBzdGF0ZSB3aXRoIEltYWdlRGVjb2RpbmdTdG9yZSB3aGVuIGltYWdlIGlz Ci0gICAgLy8gYWN0dWFsbHkgZGVjb2RlZC4gUmV0dXJuIHRydWUgaGVyZSBpcyBjb3JyZWN0IGlu IHRlcm1zIG9mIHJlbmRlcmluZyBidXQKLSAgICAvLyBtYXkgbm90IGdvIHRocm91Z2ggc29tZSBv cHRpbWl6ZWQgcmVuZGVyaW5nIGNvZGUgcGF0aC4KLSAgICByZXR1cm4gbV9hY3R1YWxEZWNvZGVy ID8gbV9hY3R1YWxEZWNvZGVyLT5mcmFtZUhhc0FscGhhQXRJbmRleChpbmRleCkgOiB0cnVlOwor ICAgIGlmICghbV9hY3R1YWxEZWNvZGVyKSB7CisgICAgICAgIExhenlEZWNvZGluZ1BpeGVsUmVm KiBwaXhlbFJlZiA9IHN0YXRpY19jYXN0PExhenlEZWNvZGluZ1BpeGVsUmVmKj4obV9sYXp5RGVj b2RlZEZyYW1lLmdldFNrQml0bWFwKCkucGl4ZWxSZWYoKSk7CisgICAgICAgIHJldHVybiBwaXhl bFJlZi0+ZnJhbWVHZW5lcmF0b3IoKS0+aGFzQWxwaGEoKTsKKyAgICB9CisgICAgcmV0dXJuIG1f YWN0dWFsRGVjb2Rlci0+ZnJhbWVIYXNBbHBoYUF0SW5kZXgoaW5kZXgpOwogfQogCiB1bnNpZ25l ZCBEZWZlcnJlZEltYWdlRGVjb2Rlcjo6ZnJhbWVCeXRlc0F0SW5kZXgoc2l6ZV90IGluZGV4KSBj b25zdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vSW1hZ2VGcmFtZUdlbmVyYXRvci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9JbWFnZUZyYW1lR2VuZXJhdG9yLmNwcAppbmRleCA5M2Y5NWVmNDQxNzMz YWUzYmY5ZGEwYWU5Mjg4NjE0OWY0YWJkNDBhLi5lY2YyMzgyMDFiOTgyOTY5MWFkYTA4NTdkM2Q0 NmU2NjkyN2RlMTU0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9JbWFnZUZyYW1lR2VuZXJhdG9yLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9JbWFnZUZyYW1lR2VuZXJhdG9yLmNwcApAQCAtNDgs NiArNDgsNyBAQCBza2lhOjpJbWFnZU9wZXJhdGlvbnM6OlJlc2l6ZU1ldGhvZCByZXNpemVNZXRo b2QoKQogSW1hZ2VGcmFtZUdlbmVyYXRvcjo6SW1hZ2VGcmFtZUdlbmVyYXRvcihjb25zdCBTa0lT aXplJiBmdWxsU2l6ZSwgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IGRhdGEsIGJvb2wgYWxsRGF0 YVJlY2VpdmVkKQogICAgIDogbV9mdWxsU2l6ZShmdWxsU2l6ZSkKICAgICAsIG1fZGVjb2RlRmFp bGVkQW5kRW1wdHkoZmFsc2UpCisgICAgLCBtX2hhc0FscGhhKHRydWUpCiB7CiAgICAgc2V0RGF0 YShkYXRhLmdldCgpLCBhbGxEYXRhUmVjZWl2ZWQpOwogfQpAQCAtMjExLDYgKzIxMiw3IEBAIFBh c3NPd25QdHI8U2NhbGVkSW1hZ2VGcmFnbWVudD4gSW1hZ2VGcmFtZUdlbmVyYXRvcjo6ZGVjb2Rl KEltYWdlRGVjb2RlcioqIGRlY29kCiAKICAgICBib29sIGlzQ29tcGxldGUgPSBmcmFtZS0+c3Rh dHVzKCkgPT0gSW1hZ2VGcmFtZTo6RnJhbWVDb21wbGV0ZTsKICAgICBTa0JpdG1hcCBmdWxsU2l6 ZUJpdG1hcCA9IGZyYW1lLT5nZXRTa0JpdG1hcCgpOworICAgIG1faGFzQWxwaGEgPSAhZnVsbFNp emVCaXRtYXAuaXNPcGFxdWUoKTsKICAgICBBU1NFUlQoZnVsbFNpemVCaXRtYXAud2lkdGgoKSA9 PSBtX2Z1bGxTaXplLndpZHRoKCkgJiYgZnVsbFNpemVCaXRtYXAuaGVpZ2h0KCkgPT0gbV9mdWxs U2l6ZS5oZWlnaHQoKSk7CiAKICAgICByZXR1cm4gU2NhbGVkSW1hZ2VGcmFnbWVudDo6Y3JlYXRl KG1fZnVsbFNpemUsIGZ1bGxTaXplQml0bWFwLCBpc0NvbXBsZXRlKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0ltYWdlRnJhbWVHZW5lcmF0 b3IuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0ltYWdlRnJh bWVHZW5lcmF0b3IuaAppbmRleCA1NTBhMDcwMjVmYjAzMzM4MjhmOGUzOWMxMDI3NTFlMmU3OGVi NmQwLi4xMDI5NGIzODYwMWJhZDBmMDRhN2MzNzhhYmUzYTk3OWJmYjljMzM0IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9JbWFnZUZyYW1lR2Vu ZXJhdG9yLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v SW1hZ2VGcmFtZUdlbmVyYXRvci5oCkBAIC02Nyw2ICs2Nyw4IEBAIHB1YmxpYzoKIAogICAgIHZv aWQgc2V0SW1hZ2VEZWNvZGVyRmFjdG9yeUZvclRlc3RpbmcoUGFzc093blB0cjxJbWFnZURlY29k ZXJGYWN0b3J5PiBmYWN0b3J5KSB7IG1faW1hZ2VEZWNvZGVyRmFjdG9yeSA9IGZhY3Rvcnk7IH0K IAorICAgIGJvb2wgaGFzQWxwaGEoKSBjb25zdCB7IHJldHVybiBtX2hhc0FscGhhOyB9CisKIHBy aXZhdGU6CiAgICAgLy8gVGhlc2UgbWV0aG9kcyBhcmUgY2FsbGVkIHdoaWxlIG1fZGVjb2RlTXV0 ZXggaXMgbG9ja2VkLgogICAgIGNvbnN0IFNjYWxlZEltYWdlRnJhZ21lbnQqIHRyeVRvTG9ja0Nv bXBsZXRlQ2FjaGUoY29uc3QgU2tJU2l6ZSYgc2NhbGVkU2l6ZSk7CkBAIC04MCw2ICs4Miw3IEBA IHByaXZhdGU6CiAgICAgU2tJU2l6ZSBtX2Z1bGxTaXplOwogICAgIFRocmVhZFNhZmVEYXRhVHJh bnNwb3J0IG1fZGF0YTsKICAgICBib29sIG1fZGVjb2RlRmFpbGVkQW5kRW1wdHk7CisgICAgYm9v bCBtX2hhc0FscGhhOwogICAgIERpc2NhcmRhYmxlUGl4ZWxSZWZBbGxvY2F0b3IgbV9hbGxvY2F0 b3I7CiAKICAgICBPd25QdHI8SW1hZ2VEZWNvZGVyRmFjdG9yeT4gbV9pbWFnZURlY29kZXJGYWN0 b3J5OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9JbWFnZUZyYW1l R2VuZXJhdG9yVGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0ltYWdlRnJh bWVHZW5lcmF0b3JUZXN0LmNwcAppbmRleCBiNDE2OWExMzliYWUzYjYzOTk3YzE0YTBjZTg0NDg0 YjVlOWI1MTE2Li4xMTNkNzg4MTZlZDFkOTEyZWI1MTM2OGE3YThmZjgxODgyMjE1ZjM5IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0ltYWdlRnJhbWVHZW5lcmF0b3JU ZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0ltYWdlRnJhbWVHZW5l cmF0b3JUZXN0LmNwcApAQCAtMTI0LDYgKzEyNCw3IEBAIFBhc3NPd25QdHI8SW1hZ2VEZWNvZGVy PiBNb2NrSW1hZ2VEZWNvZGVyRmFjdG9yeTo6Y3JlYXRlKCkKIHsKICAgICBPd25QdHI8TW9ja0lt YWdlRGVjb2Rlcj4gZGVjb2RlciA9IE1vY2tJbWFnZURlY29kZXI6OmNyZWF0ZShtX3Rlc3QpOwog ICAgIGRlY29kZXItPnNldFNpemUoZnVsbFNpemUoKS53aWR0aCgpLCBmdWxsU2l6ZSgpLmhlaWdo dCgpKTsKKyAgICBkZWNvZGVyLT5zZXRGcmFtZUhhc0FscGhhKGZhbHNlKTsKICAgICByZXR1cm4g ZGVjb2Rlci5yZWxlYXNlKCk7CiB9CiAKQEAgLTEzNyw2ICsxMzgsNyBAQCBURVNUX0YoSW1hZ2VG cmFtZUdlbmVyYXRvclRlc3QsIGNhY2hlSGl0KQogICAgIGNvbnN0IFNjYWxlZEltYWdlRnJhZ21l bnQqIHRlbXBJbWFnZSA9IG1fZ2VuZXJhdG9yLT5kZWNvZGVBbmRTY2FsZShmdWxsU2l6ZSgpKTsK ICAgICBFWFBFQ1RfRVEoZnVsbEltYWdlLCB0ZW1wSW1hZ2UpOwogICAgIEVYUEVDVF9FUShmdWxs U2l6ZSgpLCB0ZW1wSW1hZ2UtPnNjYWxlZFNpemUoKSk7CisgICAgRVhQRUNUX1RSVUUobV9nZW5l cmF0b3ItPmhhc0FscGhhKCkpOwogICAgIEltYWdlRGVjb2RpbmdTdG9yZTo6aW5zdGFuY2UoKS0+ dW5sb2NrQ2FjaGUobV9nZW5lcmF0b3IuZ2V0KCksIHRlbXBJbWFnZSk7CiAgICAgRVhQRUNUX0VR KDAsIG1fZnJhbWVCdWZmZXJSZXF1ZXN0Q291bnQpOwogfQpAQCAtMTUyLDEyICsxNTQsMTQgQEAg VEVTVF9GKEltYWdlRnJhbWVHZW5lcmF0b3JUZXN0LCBjYWNoZU1pc3NXaXRoU2NhbGUpCiAgICAg Y29uc3QgU2NhbGVkSW1hZ2VGcmFnbWVudCogc2NhbGVkSW1hZ2UgPSBtX2dlbmVyYXRvci0+ZGVj b2RlQW5kU2NhbGUoc2NhbGVkU2l6ZSgpKTsKICAgICBFWFBFQ1RfTkUoZnVsbEltYWdlLCBzY2Fs ZWRJbWFnZSk7CiAgICAgRVhQRUNUX0VRKHNjYWxlZFNpemUoKSwgc2NhbGVkSW1hZ2UtPnNjYWxl ZFNpemUoKSk7CisgICAgRVhQRUNUX1RSVUUobV9nZW5lcmF0b3ItPmhhc0FscGhhKCkpOwogICAg IEltYWdlRGVjb2RpbmdTdG9yZTo6aW5zdGFuY2UoKS0+dW5sb2NrQ2FjaGUobV9nZW5lcmF0b3Iu Z2V0KCksIHNjYWxlZEltYWdlKTsKIAogICAgIC8vIENhY2hlIGhpdC4KICAgICBjb25zdCBTY2Fs ZWRJbWFnZUZyYWdtZW50KiB0ZW1wSW1hZ2UgPSBtX2dlbmVyYXRvci0+ZGVjb2RlQW5kU2NhbGUo c2NhbGVkU2l6ZSgpKTsKICAgICBFWFBFQ1RfRVEoc2NhbGVkSW1hZ2UsIHRlbXBJbWFnZSk7CiAg ICAgRVhQRUNUX0VRKHNjYWxlZFNpemUoKSwgdGVtcEltYWdlLT5zY2FsZWRTaXplKCkpOworICAg IEVYUEVDVF9UUlVFKG1fZ2VuZXJhdG9yLT5oYXNBbHBoYSgpKTsKICAgICBJbWFnZURlY29kaW5n U3RvcmU6Omluc3RhbmNlKCktPnVubG9ja0NhY2hlKG1fZ2VuZXJhdG9yLmdldCgpLCB0ZW1wSW1h Z2UpOwogICAgIEVYUEVDVF9FUSgwLCBtX2ZyYW1lQnVmZmVyUmVxdWVzdENvdW50KTsKIH0KQEAg LTE3MCw2ICsxNzQsNyBAQCBURVNUX0YoSW1hZ2VGcmFtZUdlbmVyYXRvclRlc3QsIGNhY2hlTWlz c1dpdGhEZWNvZGVBbmRTY2FsZSkKICAgICBjb25zdCBTY2FsZWRJbWFnZUZyYWdtZW50KiBzY2Fs ZWRJbWFnZSA9IG1fZ2VuZXJhdG9yLT5kZWNvZGVBbmRTY2FsZShzY2FsZWRTaXplKCkpOwogICAg IEVYUEVDVF9FUSgxLCBtX2ZyYW1lQnVmZmVyUmVxdWVzdENvdW50KTsKICAgICBFWFBFQ1RfRVEo c2NhbGVkU2l6ZSgpLCBzY2FsZWRJbWFnZS0+c2NhbGVkU2l6ZSgpKTsKKyAgICBFWFBFQ1RfRkFM U0UobV9nZW5lcmF0b3ItPmhhc0FscGhhKCkpOwogICAgIEltYWdlRGVjb2RpbmdTdG9yZTo6aW5z dGFuY2UoKS0+dW5sb2NrQ2FjaGUobV9nZW5lcmF0b3IuZ2V0KCksIHNjYWxlZEltYWdlKTsKICAg ICBFWFBFQ1RfRVEoMSwgbV9kZWNvZGVyc0Rlc3Ryb3llZCk7CiAKQEAgLTE3NywxMiArMTgyLDE0 IEBAIFRFU1RfRihJbWFnZUZyYW1lR2VuZXJhdG9yVGVzdCwgY2FjaGVNaXNzV2l0aERlY29kZUFu ZFNjYWxlKQogICAgIGNvbnN0IFNjYWxlZEltYWdlRnJhZ21lbnQqIGZ1bGxJbWFnZSA9IG1fZ2Vu ZXJhdG9yLT5kZWNvZGVBbmRTY2FsZShmdWxsU2l6ZSgpKTsKICAgICBFWFBFQ1RfTkUoc2NhbGVk SW1hZ2UsIGZ1bGxJbWFnZSk7CiAgICAgRVhQRUNUX0VRKGZ1bGxTaXplKCksIGZ1bGxJbWFnZS0+ c2NhbGVkU2l6ZSgpKTsKKyAgICBFWFBFQ1RfRkFMU0UobV9nZW5lcmF0b3ItPmhhc0FscGhhKCkp OwogICAgIEltYWdlRGVjb2RpbmdTdG9yZTo6aW5zdGFuY2UoKS0+dW5sb2NrQ2FjaGUobV9nZW5l cmF0b3IuZ2V0KCksIGZ1bGxJbWFnZSk7CiAKICAgICAvLyBDYWNoZSBoaXQuCiAgICAgY29uc3Qg U2NhbGVkSW1hZ2VGcmFnbWVudCogdGVtcEltYWdlID0gbV9nZW5lcmF0b3ItPmRlY29kZUFuZFNj YWxlKHNjYWxlZFNpemUoKSk7CiAgICAgRVhQRUNUX0VRKHNjYWxlZEltYWdlLCB0ZW1wSW1hZ2Up OwogICAgIEVYUEVDVF9FUShzY2FsZWRTaXplKCksIHRlbXBJbWFnZS0+c2NhbGVkU2l6ZSgpKTsK KyAgICBFWFBFQ1RfRkFMU0UobV9nZW5lcmF0b3ItPmhhc0FscGhhKCkpOwogICAgIEltYWdlRGVj b2RpbmdTdG9yZTo6aW5zdGFuY2UoKS0+dW5sb2NrQ2FjaGUobV9nZW5lcmF0b3IuZ2V0KCksIHRl bXBJbWFnZSk7CiAgICAgRVhQRUNUX0VRKDEsIG1fZnJhbWVCdWZmZXJSZXF1ZXN0Q291bnQpOwog fQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9Nb2NrSW1hZ2VEZWNv ZGVyLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL01vY2tJbWFnZURlY29kZXIuaApp bmRleCA1YzlhNjIzN2I5NGY4NWJhM2ZkNjI0YmJiNTVhNzAyOWFkODlmODQxLi5iYTM0MjE3OGFi MzA5ZmI5ZjJkYWU2NDk5ODhkZjYwMjFlMmY2MjAyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3Rlc3RzL01vY2tJbWFnZURlY29kZXIuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3Rlc3RzL01vY2tJbWFnZURlY29kZXIuaApAQCAtNTksNiArNTksOCBAQCBwdWJsaWM6 CiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KIAorICAgIHZpcnR1YWwgdm9pZCBzZXRGcmFt ZUhhc0FscGhhKGJvb2wgaGFzQWxwaGEpIHsgbV9mcmFtZUJ1ZmZlckNhY2hlWzBdLnNldEhhc0Fs cGhhKGhhc0FscGhhKTsgfQorCiAgICAgdmlydHVhbCBTdHJpbmcgZmlsZW5hbWVFeHRlbnNpb24o KSBjb25zdAogICAgIHsKICAgICAgICAgcmV0dXJuICJtb2NrIjsK 188163 2013-02-13 13:23:42 -0800 2013-02-14 10:51:07 -0800 Patch bug-108892-20130213132011.patch text/plain 9919 qinmin U3VidmVyc2lvbiBSZXZpc2lvbjogMTQyNzIzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmYyZGM3MTc5MDA4OTlh OTQyZjY0ZmE0OWI5OGM2NzE3MjY4M2UyOC4uNWRlNWQwMmViMDdhODI5ODI0NWIyMTM5ZTYxMjdm ODA4YmI3NjI3ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMxIEBACisyMDEzLTAyLTA1ICBNaW4g UWluICA8cWlubWluQGNocm9taXVtLm9yZz4KKworICAgICAgICBQYXNzaW5nIGFscGhhIHRvIERl ZmVycmVkSW1hZ2VEZWNvZGVyIG9uY2UgZGVjb2RpbmcgY29tcGxldGVzCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDg4OTIKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXZSBzaG91bGQgcGFzcyBoYXNBbHBo YSB2YWx1ZSBiYWNrIHRvIHRoZSBEZWZlcnJlZEltYWdlRGVjb2RlciBvbmNlIGRlY29kaW5nIGlz IGNvbXBsZXRlZAorICAgICAgICBBZGRlZCB1bml0IHRlc3RzIGluIEltYWdlRnJhbWVHZW5lcmF0 b3JUZXN0LgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRGVmZXJyZWRJ bWFnZURlY29kZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVmZXJyZWRJbWFnZURlY29kZXI6 OmZyYW1lSGFzQWxwaGFBdEluZGV4KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9JbWFnZUZyYW1lR2VuZXJhdG9yLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkltYWdlRnJh bWVHZW5lcmF0b3I6OnRyeVRvU2NhbGUpOgorICAgICAgICAoV2ViQ29yZTo6SW1hZ2VGcmFtZUdl bmVyYXRvcjo6ZGVjb2RlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXp5RGVjb2RpbmdQaXhlbFJlZi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXp5RGVjb2RpbmdQ aXhlbFJlZjo6TGF6eURlY29kaW5nUGl4ZWxSZWYpOgorICAgICAgICAoV2ViQ29yZTo6TGF6eURl Y29kaW5nUGl4ZWxSZWY6Om9uVW5sb2NrUGl4ZWxzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXp5RGVjb2RpbmdQaXhlbFJlZi5oOgorICAgICAgICAoV2ViQ29yZTo6 TGF6eURlY29kaW5nUGl4ZWxSZWY6Omhhc0FscGhhKToKKyAgICAgICAgKExhenlEZWNvZGluZ1Bp eGVsUmVmKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9TY2FsZWRJbWFn ZUZyYWdtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjYWxlZEltYWdlRnJhZ21lbnQ6OlNj YWxlZEltYWdlRnJhZ21lbnQpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L1NjYWxlZEltYWdlRnJhZ21lbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNjYWxlZEltYWdlRnJh Z21lbnQ6OmNyZWF0ZSk6CisgICAgICAgIChTY2FsZWRJbWFnZUZyYWdtZW50KToKKyAgICAgICAg KFdlYkNvcmU6OlNjYWxlZEltYWdlRnJhZ21lbnQ6Omhhc0FscGhhKToKKwogMjAxMy0wMi0xMiAg Q2hyaXMgRmxlaXphY2ggIDxjZmxlaXphY2hAYXBwbGUuY29tPgogCiAgICAgICAgICBBWDogY3Jh c2ggd2hlbiBhY2Nlc3NpbmcgQWNjZXNzaWJpbGl0eVNjcm9sbGJhciBhZnRlciBwYWdlIGhhcyBi ZWVuIHVubG9hZGVkCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxv ZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDY3M2ViMjBkOTkyNjlk NmU4OGI2MmE2ZDQwZTI0ZGQzZGIwMDA3NjQuLjQzNDYwYmI3YmEyMzM4MGJiMWNkODdiY2Q5NjMx NTc2ZDk5MDQ0YzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAK KzIwMTMtMDItMDUgIE1pbiBRaW4gIDxxaW5taW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFBh c3NpbmcgYWxwaGEgdG8gRGVmZXJyZWRJbWFnZURlY29kZXIgb25jZSBkZWNvZGluZyBjb21wbGV0 ZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwODg5 MgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCB0 ZXN0IHRvIGNoZWNrIHRoYXQgYWxwaGEgdmFsdWUgaXMgcGFzc2VkIGZyb20gdGhlIGRlY29kZXIg dG8gSW1hZ2VGcmFtZUdlbmVyYXRvci4KKworICAgICAgICAqIHRlc3RzL0ltYWdlRnJhbWVHZW5l cmF0b3JUZXN0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1vY2tJbWFnZURlY29kZXJGYWN0b3J5 OjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6VEVTVF9GKToKKyAgICAgICAgKiB0ZXN0cy9N b2NrSW1hZ2VEZWNvZGVyLmg6CisgICAgICAgIChXZWJDb3JlOjpNb2NrSW1hZ2VEZWNvZGVyOjpN b2NrSW1hZ2VEZWNvZGVyKToKKyAgICAgICAgKFdlYkNvcmU6Ok1vY2tJbWFnZURlY29kZXI6OnNl dEZyYW1lSGFzQWxwaGEpOgorICAgICAgICAoTW9ja0ltYWdlRGVjb2Rlcik6CisgICAgICAgIChX ZWJDb3JlOjpNb2NrSW1hZ2VEZWNvZGVyOjpmcmFtZUhhc0FscGhhQXRJbmRleCk6CisKIDIwMTMt MDItMTIgIFlvc2hpZnVtaSBJbm91ZSAgPHlvc2luQGNocm9taXVtLm9yZz4KIAogICAgICAgICBV bnJldmlld2VkLiBCdWlsZCBmaXggZm9yIENocm9taXVtLVdpbi4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0RlZmVycmVkSW1hZ2VEZWNvZGVy LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0RlZmVycmVk SW1hZ2VEZWNvZGVyLmNwcAppbmRleCAwNTBmNDM5ZTU5NmNiOTU1M2JhMWVkNzE1ZDg5ZjdiOTM4 M2I5MmU5Li5iZjAzZjk5MWI2Mjk4OGU3Y2Y4NTE2NzMzZGU0MGE1NjZhMjEyYTIyIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9EZWZlcnJlZElt YWdlRGVjb2Rlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vRGVmZXJyZWRJbWFnZURlY29kZXIuY3BwCkBAIC0xODEsMTAgKzE4MSw3IEBAIHZvaWQg RGVmZXJyZWRJbWFnZURlY29kZXI6OmNsZWFyRnJhbWVCdWZmZXJDYWNoZShzaXplX3QgY2xlYXJC ZWZvcmVGcmFtZSkKIAogYm9vbCBEZWZlcnJlZEltYWdlRGVjb2Rlcjo6ZnJhbWVIYXNBbHBoYUF0 SW5kZXgoc2l6ZV90IGluZGV4KSBjb25zdAogewotICAgIC8vIEZJWE1FOiBTeW5jaHJvbml6ZSB0 aGlzIHN0YXRlIHdpdGggSW1hZ2VEZWNvZGluZ1N0b3JlIHdoZW4gaW1hZ2UgaXMKLSAgICAvLyBh Y3R1YWxseSBkZWNvZGVkLiBSZXR1cm4gdHJ1ZSBoZXJlIGlzIGNvcnJlY3QgaW4gdGVybXMgb2Yg cmVuZGVyaW5nIGJ1dAotICAgIC8vIG1heSBub3QgZ28gdGhyb3VnaCBzb21lIG9wdGltaXplZCBy ZW5kZXJpbmcgY29kZSBwYXRoLgotICAgIHJldHVybiBtX2FjdHVhbERlY29kZXIgPyBtX2FjdHVh bERlY29kZXItPmZyYW1lSGFzQWxwaGFBdEluZGV4KGluZGV4KSA6IHRydWU7CisgICAgcmV0dXJu IG1fYWN0dWFsRGVjb2RlciA/IG1fYWN0dWFsRGVjb2Rlci0+ZnJhbWVIYXNBbHBoYUF0SW5kZXgo aW5kZXgpIDogbV9mcmFtZUdlbmVyYXRvci0+aGFzQWxwaGEoKTsKIH0KIAogdW5zaWduZWQgRGVm ZXJyZWRJbWFnZURlY29kZXI6OmZyYW1lQnl0ZXNBdEluZGV4KHNpemVfdCBpbmRleCkgY29uc3QK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0lt YWdlRnJhbWVHZW5lcmF0b3IuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vSW1hZ2VGcmFtZUdlbmVyYXRvci5jcHAKaW5kZXggOTNmOTVlZjQ0MTczM2FlM2Jm OWRhMGFlOTI4ODYxNDlmNGFiZDQwYS4uZDM0ZjU0NmMxZjc5NDAwN2JhMjNmMTE0MzAyZWUzZWI2 ZDEzOTEzYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vSW1hZ2VGcmFtZUdlbmVyYXRvci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VGcmFtZUdlbmVyYXRvci5jcHAKQEAgLTQ4LDYgKzQ4 LDcgQEAgc2tpYTo6SW1hZ2VPcGVyYXRpb25zOjpSZXNpemVNZXRob2QgcmVzaXplTWV0aG9kKCkK IEltYWdlRnJhbWVHZW5lcmF0b3I6OkltYWdlRnJhbWVHZW5lcmF0b3IoY29uc3QgU2tJU2l6ZSYg ZnVsbFNpemUsIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBkYXRhLCBib29sIGFsbERhdGFSZWNl aXZlZCkKICAgICA6IG1fZnVsbFNpemUoZnVsbFNpemUpCiAgICAgLCBtX2RlY29kZUZhaWxlZEFu ZEVtcHR5KGZhbHNlKQorICAgICwgbV9oYXNBbHBoYSh0cnVlKQogewogICAgIHNldERhdGEoZGF0 YS5nZXQoKSwgYWxsRGF0YVJlY2VpdmVkKTsKIH0KQEAgLTIxMSw5ICsyMTIsMTkgQEAgUGFzc093 blB0cjxTY2FsZWRJbWFnZUZyYWdtZW50PiBJbWFnZUZyYW1lR2VuZXJhdG9yOjpkZWNvZGUoSW1h Z2VEZWNvZGVyKiogZGVjb2QKIAogICAgIGJvb2wgaXNDb21wbGV0ZSA9IGZyYW1lLT5zdGF0dXMo KSA9PSBJbWFnZUZyYW1lOjpGcmFtZUNvbXBsZXRlOwogICAgIFNrQml0bWFwIGZ1bGxTaXplQml0 bWFwID0gZnJhbWUtPmdldFNrQml0bWFwKCk7CisgICAgeworICAgICAgICBNdXRleExvY2tlciBs b2NrKG1fYWxwaGFNdXRleCk7CisgICAgICAgIG1faGFzQWxwaGEgPSAhZnVsbFNpemVCaXRtYXAu aXNPcGFxdWUoKTsKKyAgICB9CiAgICAgQVNTRVJUKGZ1bGxTaXplQml0bWFwLndpZHRoKCkgPT0g bV9mdWxsU2l6ZS53aWR0aCgpICYmIGZ1bGxTaXplQml0bWFwLmhlaWdodCgpID09IG1fZnVsbFNp emUuaGVpZ2h0KCkpOwogCiAgICAgcmV0dXJuIFNjYWxlZEltYWdlRnJhZ21lbnQ6OmNyZWF0ZSht X2Z1bGxTaXplLCBmdWxsU2l6ZUJpdG1hcCwgaXNDb21wbGV0ZSk7CiB9CiAKK2Jvb2wgSW1hZ2VG cmFtZUdlbmVyYXRvcjo6aGFzQWxwaGEoKQoreworICAgIE11dGV4TG9ja2VyIGxvY2sobV9hbHBo YU11dGV4KTsKKyAgICByZXR1cm4gbV9oYXNBbHBoYTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vSW1hZ2VGcmFtZUdlbmVyYXRvci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vSW1hZ2VGcmFtZUdlbmVyYXRvci5oCmluZGV4IDU1MGEwNzAyNWZiMDMzMzgy OGY4ZTM5YzEwMjc1MWUyZTc4ZWI2ZDAuLjM0M2U3YjUxZWM2ZDQwYjBjN2EwYTE1ODZjNjg5NjZk YmI0MTBiNzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0ltYWdlRnJhbWVHZW5lcmF0b3IuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9JbWFnZUZyYW1lR2VuZXJhdG9yLmgKQEAgLTY3LDYgKzY3LDgg QEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRJbWFnZURlY29kZXJGYWN0b3J5Rm9yVGVzdGluZyhQ YXNzT3duUHRyPEltYWdlRGVjb2RlckZhY3Rvcnk+IGZhY3RvcnkpIHsgbV9pbWFnZURlY29kZXJG YWN0b3J5ID0gZmFjdG9yeTsgfQogCisgICAgYm9vbCBoYXNBbHBoYSgpOworCiBwcml2YXRlOgog ICAgIC8vIFRoZXNlIG1ldGhvZHMgYXJlIGNhbGxlZCB3aGlsZSBtX2RlY29kZU11dGV4IGlzIGxv Y2tlZC4KICAgICBjb25zdCBTY2FsZWRJbWFnZUZyYWdtZW50KiB0cnlUb0xvY2tDb21wbGV0ZUNh Y2hlKGNvbnN0IFNrSVNpemUmIHNjYWxlZFNpemUpOwpAQCAtODAsMTIgKzgyLDE2IEBAIHByaXZh dGU6CiAgICAgU2tJU2l6ZSBtX2Z1bGxTaXplOwogICAgIFRocmVhZFNhZmVEYXRhVHJhbnNwb3J0 IG1fZGF0YTsKICAgICBib29sIG1fZGVjb2RlRmFpbGVkQW5kRW1wdHk7CisgICAgYm9vbCBtX2hh c0FscGhhOwogICAgIERpc2NhcmRhYmxlUGl4ZWxSZWZBbGxvY2F0b3IgbV9hbGxvY2F0b3I7CiAK ICAgICBPd25QdHI8SW1hZ2VEZWNvZGVyRmFjdG9yeT4gbV9pbWFnZURlY29kZXJGYWN0b3J5Owog CiAgICAgLy8gUHJldmVudHMgbXVsdGlwbGUgZGVjb2RlIG9wZXJhdGlvbnMgb24gdGhlIHNhbWUg ZGF0YS4KICAgICBNdXRleCBtX2RlY29kZU11dGV4OworCisgICAgLy8gUHJvdGVjdCBjb25jdXJy ZW50IGFjY2VzcyB0byBtX2hhc0FscGhhLgorICAgIE11dGV4IG1fYWxwaGFNdXRleDsKIH07CiAK IH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vdGVzdHMvSW1hZ2VGcmFtZUdlbmVyYXRvclRlc3QuY3BwIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS90ZXN0cy9JbWFnZUZyYW1lR2VuZXJhdG9yVGVzdC5jcHAKaW5kZXggYjQxNjlhMTM5YmFl M2I2Mzk5N2MxNGEwY2U4NDQ4NGI1ZTliNTExNi4uMTEzZDc4ODE2ZWQxZDkxMmViNTEzNjhhN2E4 ZmY4MTg4MjIxNWYzOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9J bWFnZUZyYW1lR2VuZXJhdG9yVGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90 ZXN0cy9JbWFnZUZyYW1lR2VuZXJhdG9yVGVzdC5jcHAKQEAgLTEyNCw2ICsxMjQsNyBAQCBQYXNz T3duUHRyPEltYWdlRGVjb2Rlcj4gTW9ja0ltYWdlRGVjb2RlckZhY3Rvcnk6OmNyZWF0ZSgpCiB7 CiAgICAgT3duUHRyPE1vY2tJbWFnZURlY29kZXI+IGRlY29kZXIgPSBNb2NrSW1hZ2VEZWNvZGVy OjpjcmVhdGUobV90ZXN0KTsKICAgICBkZWNvZGVyLT5zZXRTaXplKGZ1bGxTaXplKCkud2lkdGgo KSwgZnVsbFNpemUoKS5oZWlnaHQoKSk7CisgICAgZGVjb2Rlci0+c2V0RnJhbWVIYXNBbHBoYShm YWxzZSk7CiAgICAgcmV0dXJuIGRlY29kZXIucmVsZWFzZSgpOwogfQogCkBAIC0xMzcsNiArMTM4 LDcgQEAgVEVTVF9GKEltYWdlRnJhbWVHZW5lcmF0b3JUZXN0LCBjYWNoZUhpdCkKICAgICBjb25z dCBTY2FsZWRJbWFnZUZyYWdtZW50KiB0ZW1wSW1hZ2UgPSBtX2dlbmVyYXRvci0+ZGVjb2RlQW5k U2NhbGUoZnVsbFNpemUoKSk7CiAgICAgRVhQRUNUX0VRKGZ1bGxJbWFnZSwgdGVtcEltYWdlKTsK ICAgICBFWFBFQ1RfRVEoZnVsbFNpemUoKSwgdGVtcEltYWdlLT5zY2FsZWRTaXplKCkpOworICAg IEVYUEVDVF9UUlVFKG1fZ2VuZXJhdG9yLT5oYXNBbHBoYSgpKTsKICAgICBJbWFnZURlY29kaW5n U3RvcmU6Omluc3RhbmNlKCktPnVubG9ja0NhY2hlKG1fZ2VuZXJhdG9yLmdldCgpLCB0ZW1wSW1h Z2UpOwogICAgIEVYUEVDVF9FUSgwLCBtX2ZyYW1lQnVmZmVyUmVxdWVzdENvdW50KTsKIH0KQEAg LTE1MiwxMiArMTU0LDE0IEBAIFRFU1RfRihJbWFnZUZyYW1lR2VuZXJhdG9yVGVzdCwgY2FjaGVN aXNzV2l0aFNjYWxlKQogICAgIGNvbnN0IFNjYWxlZEltYWdlRnJhZ21lbnQqIHNjYWxlZEltYWdl ID0gbV9nZW5lcmF0b3ItPmRlY29kZUFuZFNjYWxlKHNjYWxlZFNpemUoKSk7CiAgICAgRVhQRUNU X05FKGZ1bGxJbWFnZSwgc2NhbGVkSW1hZ2UpOwogICAgIEVYUEVDVF9FUShzY2FsZWRTaXplKCks IHNjYWxlZEltYWdlLT5zY2FsZWRTaXplKCkpOworICAgIEVYUEVDVF9UUlVFKG1fZ2VuZXJhdG9y LT5oYXNBbHBoYSgpKTsKICAgICBJbWFnZURlY29kaW5nU3RvcmU6Omluc3RhbmNlKCktPnVubG9j a0NhY2hlKG1fZ2VuZXJhdG9yLmdldCgpLCBzY2FsZWRJbWFnZSk7CiAKICAgICAvLyBDYWNoZSBo aXQuCiAgICAgY29uc3QgU2NhbGVkSW1hZ2VGcmFnbWVudCogdGVtcEltYWdlID0gbV9nZW5lcmF0 b3ItPmRlY29kZUFuZFNjYWxlKHNjYWxlZFNpemUoKSk7CiAgICAgRVhQRUNUX0VRKHNjYWxlZElt YWdlLCB0ZW1wSW1hZ2UpOwogICAgIEVYUEVDVF9FUShzY2FsZWRTaXplKCksIHRlbXBJbWFnZS0+ c2NhbGVkU2l6ZSgpKTsKKyAgICBFWFBFQ1RfVFJVRShtX2dlbmVyYXRvci0+aGFzQWxwaGEoKSk7 CiAgICAgSW1hZ2VEZWNvZGluZ1N0b3JlOjppbnN0YW5jZSgpLT51bmxvY2tDYWNoZShtX2dlbmVy YXRvci5nZXQoKSwgdGVtcEltYWdlKTsKICAgICBFWFBFQ1RfRVEoMCwgbV9mcmFtZUJ1ZmZlclJl cXVlc3RDb3VudCk7CiB9CkBAIC0xNzAsNiArMTc0LDcgQEAgVEVTVF9GKEltYWdlRnJhbWVHZW5l cmF0b3JUZXN0LCBjYWNoZU1pc3NXaXRoRGVjb2RlQW5kU2NhbGUpCiAgICAgY29uc3QgU2NhbGVk SW1hZ2VGcmFnbWVudCogc2NhbGVkSW1hZ2UgPSBtX2dlbmVyYXRvci0+ZGVjb2RlQW5kU2NhbGUo c2NhbGVkU2l6ZSgpKTsKICAgICBFWFBFQ1RfRVEoMSwgbV9mcmFtZUJ1ZmZlclJlcXVlc3RDb3Vu dCk7CiAgICAgRVhQRUNUX0VRKHNjYWxlZFNpemUoKSwgc2NhbGVkSW1hZ2UtPnNjYWxlZFNpemUo KSk7CisgICAgRVhQRUNUX0ZBTFNFKG1fZ2VuZXJhdG9yLT5oYXNBbHBoYSgpKTsKICAgICBJbWFn ZURlY29kaW5nU3RvcmU6Omluc3RhbmNlKCktPnVubG9ja0NhY2hlKG1fZ2VuZXJhdG9yLmdldCgp LCBzY2FsZWRJbWFnZSk7CiAgICAgRVhQRUNUX0VRKDEsIG1fZGVjb2RlcnNEZXN0cm95ZWQpOwog CkBAIC0xNzcsMTIgKzE4MiwxNCBAQCBURVNUX0YoSW1hZ2VGcmFtZUdlbmVyYXRvclRlc3QsIGNh Y2hlTWlzc1dpdGhEZWNvZGVBbmRTY2FsZSkKICAgICBjb25zdCBTY2FsZWRJbWFnZUZyYWdtZW50 KiBmdWxsSW1hZ2UgPSBtX2dlbmVyYXRvci0+ZGVjb2RlQW5kU2NhbGUoZnVsbFNpemUoKSk7CiAg ICAgRVhQRUNUX05FKHNjYWxlZEltYWdlLCBmdWxsSW1hZ2UpOwogICAgIEVYUEVDVF9FUShmdWxs U2l6ZSgpLCBmdWxsSW1hZ2UtPnNjYWxlZFNpemUoKSk7CisgICAgRVhQRUNUX0ZBTFNFKG1fZ2Vu ZXJhdG9yLT5oYXNBbHBoYSgpKTsKICAgICBJbWFnZURlY29kaW5nU3RvcmU6Omluc3RhbmNlKCkt PnVubG9ja0NhY2hlKG1fZ2VuZXJhdG9yLmdldCgpLCBmdWxsSW1hZ2UpOwogCiAgICAgLy8gQ2Fj aGUgaGl0LgogICAgIGNvbnN0IFNjYWxlZEltYWdlRnJhZ21lbnQqIHRlbXBJbWFnZSA9IG1fZ2Vu ZXJhdG9yLT5kZWNvZGVBbmRTY2FsZShzY2FsZWRTaXplKCkpOwogICAgIEVYUEVDVF9FUShzY2Fs ZWRJbWFnZSwgdGVtcEltYWdlKTsKICAgICBFWFBFQ1RfRVEoc2NhbGVkU2l6ZSgpLCB0ZW1wSW1h Z2UtPnNjYWxlZFNpemUoKSk7CisgICAgRVhQRUNUX0ZBTFNFKG1fZ2VuZXJhdG9yLT5oYXNBbHBo YSgpKTsKICAgICBJbWFnZURlY29kaW5nU3RvcmU6Omluc3RhbmNlKCktPnVubG9ja0NhY2hlKG1f Z2VuZXJhdG9yLmdldCgpLCB0ZW1wSW1hZ2UpOwogICAgIEVYUEVDVF9FUSgxLCBtX2ZyYW1lQnVm ZmVyUmVxdWVzdENvdW50KTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v dGVzdHMvTW9ja0ltYWdlRGVjb2Rlci5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9N b2NrSW1hZ2VEZWNvZGVyLmgKaW5kZXggNWM5YTYyMzdiOTRmODViYTNmZDYyNGJiYjU1YTcwMjlh ZDg5Zjg0MS4uYmEzNDIxNzhhYjMwOWZiOWYyZGFlNjQ5OTg4ZGY2MDIxZTJmNjIwMiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9Nb2NrSW1hZ2VEZWNvZGVyLmgKKysr IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9Nb2NrSW1hZ2VEZWNvZGVyLmgKQEAgLTU5 LDYgKzU5LDggQEAgcHVibGljOgogICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9CiAKKyAgICB2 aXJ0dWFsIHZvaWQgc2V0RnJhbWVIYXNBbHBoYShib29sIGhhc0FscGhhKSB7IG1fZnJhbWVCdWZm ZXJDYWNoZVswXS5zZXRIYXNBbHBoYShoYXNBbHBoYSk7IH0KKwogICAgIHZpcnR1YWwgU3RyaW5n IGZpbGVuYW1lRXh0ZW5zaW9uKCkgY29uc3QKICAgICB7CiAgICAgICAgIHJldHVybiAibW9jayI7 Cg==