115364 2013-04-29 10:59:39 -0700 [SOUP] Move default buffer handling from ResourceHandleClient to ResourceHandleSoup 2013-04-30 11:19:30 -0700 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 cgarcia webkit-unassigned ap beidson commit-queue danw gustavo menard mrobinson pnormand rakuco oldest_to_newest 882681 0 cgarcia 2013-04-29 10:59:39 -0700 I don't think ResourceHandleClient that is cross-platform file is the right place for the default ResourceHandle read buffer. We can make GetBuffer return 0 by default and handle it in ResourceHandleSoup, creating a default buffer when the client doesn't provide one. 882687 1 200029 cgarcia 2013-04-29 11:08:20 -0700 Created attachment 200029 Patch 882725 2 200029 mrobinson 2013-04-29 12:54:51 -0700 Comment on attachment 200029 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=200029&action=review This is a really good change! I have just a couple small questions. > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:56 > - virtual char* getBuffer(int, int*); > + virtual char* getOrCreateReadBuffer(size_t requestedSize, size_t& actualSize); I wonder if this should return a PassRefPtr<SharedBuffer> which would make it more similar to the rest of the networking code and allow for removing the actualSize argument. Another small comment is that you probably want this to be called createBuffer. It seems that the ResourceHandle is always responsible for freeing the buffer (unless I have misread this patch), so this method is essentially a constructor since it passes ownership. That's another reason why I suggested a return value wrapped in PassRefPtr above. If we had a PassGOwnPtr it would make sense here. In fact, this reminds me to investigate removing GOwnPtr completely again. :) 882951 3 cgarcia 2013-04-30 00:50:18 -0700 (In reply to comment #2) > (From update of attachment 200029 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=200029&action=review > > This is a really good change! I have just a couple small questions. > > > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:56 > > - virtual char* getBuffer(int, int*); > > + virtual char* getOrCreateReadBuffer(size_t requestedSize, size_t& actualSize); > > I wonder if this should return a PassRefPtr<SharedBuffer> which would make it more similar to the rest of the networking code and allow for removing the actualSize argument. This was added for performance issues when reading media streams. What we want is a pointer to a buffer that can be used with read operations (g_input_stream_read_async). A shared buffer has its own memory handling and a lot of logic we don't really need. What we want here is that the GST source element can create a GstBuffer and pass the pointer to the network layer to be used directly for reading, avoiding any intermediate allocation-copy-deallocation. I think other networks bakends receive already a buffer from their network layer, so they have to copy it anyway. In such cases a SharedBuffer is perfect to fill it with data and read it incrementally. > Another small comment is that you probably want this to be called createBuffer. It seems that the ResourceHandle is always responsible for freeing the buffer (unless I have misread this patch), so this method is essentially a constructor since it passes ownership. That's another reason why I suggested a return value wrapped in PassRefPtr above. If we had a PassGOwnPtr it would make sense here. In fact, this reminds me to investigate removing GOwnPtr completely again. :) You have misread the patch :-) The method is in the client and the owner of the buffer is the client. But if the client doesn't provide a buffer, the resource handle creates its own one, and is the owner of that one, of course. Depending on how the buffer handling is implemented, the function will return a new buffer or reuse a existing one (like we do with the default buffer), that's why it's called getOrCreateReadBuffer. 883088 4 200029 mrobinson 2013-04-30 08:45:27 -0700 Comment on attachment 200029 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=200029&action=review > Source/WebCore/platform/network/soup/ResourceHandleSoup.cpp:321 > + } else if (d->m_readBufferSize < defaultReadBufferSize) { > + d->m_readBuffer.set(static_cast<char*>(g_malloc(defaultReadBufferSize))); > + d->m_readBufferPtr = d->m_readBuffer.get(); > + d->m_readBufferSize = defaultReadBufferSize; > + } else > + d->m_readBufferPtr = d->m_readBuffer.get(); In what case is d->m_readBufferSize ever less than the defaultReadBufferSize? Reading this code, I can see only one situation, which is if getOrCreateReadBuffer returns one that is smaller than the default size. If that's the case that you're dealing with here, why not check the size instead of just the return value of bufferPtr? Likewise, I don't get the final else case. If d->m_readBuffer is allocated at all, shouldn't d->m_readBufferPtr point to it anyway -- since when you get a valid return value from getOrCreateReadBuffer you reset m_readBuffer and m_readBufferPtr. Are you expecting ResourceHandleInternal to be shared between ResourceHandles? Even in that case, the internal buffer (m_readBuffer) is always the same size. > You have misread the patch :-) The method is in the client and the owner of the buffer is the client. But if the client doesn't provide a buffer, the resource handle creates its own one, and is the owner of that one, of course. Depending on how the buffer handling is implemented, the function will return a new buffer or reuse a existing one (like we do with the default buffer), that's why it's called getOrCreateReadBuffer. I see now that d->m_readBuffer is not set to the return value of getOrCreateReadBuffer. The use of the word "Create" is a bit confusing here since it's used for constructors quite a bit in WebKit. Perhaps just "getReadBuffer" or "getClientReadBuffer." Another naming nit is that the distinction between readBuffer and readBufferPtr is a bit unclear. How do you feel about Cairo terminology: m_readBuffer/m_embeddedReadBuffer or m_readBufferPtr/m_embeddedReadBuffer. 883090 5 cgarcia 2013-04-30 08:56:46 -0700 (In reply to comment #4) > (From update of attachment 200029 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=200029&action=review > > > Source/WebCore/platform/network/soup/ResourceHandleSoup.cpp:321 > > + } else if (d->m_readBufferSize < defaultReadBufferSize) { > > + d->m_readBuffer.set(static_cast<char*>(g_malloc(defaultReadBufferSize))); > > + d->m_readBufferPtr = d->m_readBuffer.get(); > > + d->m_readBufferSize = defaultReadBufferSize; > > + } else > > + d->m_readBufferPtr = d->m_readBuffer.get(); > > In what case is d->m_readBufferSize ever less than the defaultReadBufferSize? The first time. > Reading this code, I can see only one situation, which is if getOrCreateReadBuffer returns one that is smaller than the default size. In such case the default buffer is not used. The caller is not supposed to change the size parameter unless a valid pointer is returned. > If that's the case that you're dealing with here, why not check the size instead of just the return value of bufferPtr? The default implementation returns NULL and the size out parameter is not changed. We only expect to receive a size when a valid pointer is returned by the client. > Likewise, I don't get the final else case. If d->m_readBuffer is allocated at all, shouldn't d->m_readBufferPtr point to it anyway -- since when you get a valid return value from getOrCreateReadBuffer you reset m_readBuffer and m_readBufferPtr. That's for redirections, in case of redirection the current soup request is cleaned up (and Ptr is set to 0) and a new one is started for the new request, but we still want to reuse the buffer instead of free/alloc. > Are you expecting ResourceHandleInternal to be shared between ResourceHandles? No. > Even in that case, the internal buffer (m_readBuffer) is always the same size. That's true, we could just check if the m_buffer is NULL or not like the current code does, instead of checking the size. I added the size check in case the size could change in the future, but maybe it's confusing, so I can change it to check the default buffer pointer instead. > > You have misread the patch :-) The method is in the client and the owner of the buffer is the client. But if the client doesn't provide a buffer, the resource handle creates its own one, and is the owner of that one, of course. Depending on how the buffer handling is implemented, the function will return a new buffer or reuse a existing one (like we do with the default buffer), that's why it's called getOrCreateReadBuffer. > > I see now that d->m_readBuffer is not set to the return value of getOrCreateReadBuffer. The use of the word "Create" is a bit confusing here since it's used for constructors quite a bit in WebKit. Perhaps just "getReadBuffer" or "getClientReadBuffer." Another naming nit is that the distinction between readBuffer and readBufferPtr is a bit unclear. How do you feel about Cairo terminology: m_readBuffer/m_embeddedReadBuffer or m_readBufferPtr/m_embeddedReadBuffer. I don't really mind to change the name, but the method, creates a buffer or returns an existing one, it's pretty clear to me. Regarding the variable name, embedded sounds confusing to me. What bout m_readBufferPtr and m_defaultReadBuffer? 883099 6 mrobinson 2013-04-30 09:09:34 -0700 (In reply to comment #5) > > Likewise, I don't get the final else case. If d->m_readBuffer is allocated at all, shouldn't d->m_readBufferPtr point to it anyway -- since when you get a valid return value from getOrCreateReadBuffer you reset m_readBuffer and m_readBufferPtr. > > That's for redirections, in case of redirection the current soup request is cleaned up (and Ptr is set to 0) and a new one is started for the new request, but we still want to reuse the buffer instead of free/alloc. Ah, interesting. You need to set m_readBufferPtr to null in order to trigger the creation of a new client buffer. Tricky. > > Even in that case, the internal buffer (m_readBuffer) is always the same size. > > That's true, we could just check if the m_buffer is NULL or not like the current code does, instead of checking the size. I added the size check in case the size could change in the future, but maybe it's confusing, so I can change it to check the default buffer pointer instead. I think a NULL check would be a bit clearer, since the size applies to both the embedded/default buffer and the one from the client. > I don't really mind to change the name, but the method, creates a buffer or returns an existing one, it's pretty clear to me. Regarding the variable name, embedded sounds confusing to me. What bout m_readBufferPtr and m_defaultReadBuffer? m_defaultReadBuffer, m_internalReadBuffer, m_embeddedReadBuffer all sound good to me. Just so there's a distinction somehow. Thanks. 883101 7 200029 mrobinson 2013-04-30 09:10:33 -0700 Comment on attachment 200029 Patch Looks good! All my questions are answered. I'd prefer a few renames, but there's nothing blocking this patch other than that. 883120 8 cgarcia 2013-04-30 09:40:29 -0700 (In reply to comment #7) > (From update of attachment 200029 [details]) > Looks good! All my questions are answered. I'd prefer a few renames, but there's nothing blocking this patch other than that. Thanks, I'll do the renames and will change the pointer check before landing. 883170 9 cgarcia 2013-04-30 11:19:30 -0700 Committed r149383: <http://trac.webkit.org/changeset/149383> 200029 2013-04-29 11:08:20 -0700 2013-04-30 09:10:33 -0700 Patch soup-read-buffer.diff text/plain 14210 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBkNTExZmVkLi45MTRkM2VmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDUg QEAKKzIwMTMtMDQtMjkgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIFtTT1VQXSBNb3ZlIGRlZmF1bHQgYnVmZmVyIGhhbmRsaW5nIGZyb20gUmVz b3VyY2VIYW5kbGVDbGllbnQgdG8gUmVzb3VyY2VIYW5kbGVzb3VwCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTUzNjQKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZXNvdXJjZUhhbmRsZUNsaWVudCB0aGF0 IGlzIGNyb3NzLXBsYXRmb3JtIGZpbGUgaXMgbm90IHRoZSByaWdodAorICAgICAgICBwbGFjZSBm b3IgdGhlIGRlZmF1bHQgUmVzb3VyY2VIYW5kbGUgcmVhZCBidWZmZXIuIFdlIGNhbiBtYWtlCisg ICAgICAgIGdldEJ1ZmZlciByZXR1cm4gMCBieSBkZWZhdWx0IGFuZCBoYW5kbGUgaXQgaW4gUmVz b3VyY2VIYW5kbGVTb3VwLAorICAgICAgICBjcmVhdGluZyBhIGRlZmF1bHQgYnVmZmVyIHdoZW4g dGhlIGNsaWVudCBkb2Vzbid0IHByb3ZpZGUgb25lLgorCisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvZ3N0cmVhbWVyL1dlYktpdFdlYlNvdXJjZUdTdHJlYW1lci5jcHA6CisgICAgICAgIChT dHJlYW1pbmdDbGllbnQ6OmdldE9yQ3JlYXRlUmVhZEJ1ZmZlcik6IEFkYXB0IHRvIEFQSSBjaGFu Z2UuCisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oOgorICAgICAg ICAoUmVzb3VyY2VIYW5kbGUpOiBBZGQgZW5zdXJlUmVhZEJ1ZmZlcigpLgorICAgICAgICAqIHBs YXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVDbGllbnQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6UmVzb3VyY2VIYW5kbGVDbGllbnQ6On5SZXNvdXJjZUhhbmRsZUNsaWVudCk6IFJlbW92ZQor ICAgICAgICBzb3VwIHNwZWNpZmljIGNvZGUuCisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9S ZXNvdXJjZUhhbmRsZUNsaWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGVD bGllbnQ6OmdldE9yQ3JlYXRlUmVhZEJ1ZmZlcik6IFJlbmFtZQorICAgICAgICBnZXRCdWZmZXIo KSBhcyBnZXRPckNyZWF0ZVJlYWRCdWZmZXIoKSBhbmQgdXNlIGEgcmVmZXJlbmNlIGZvciB0aGUK KyAgICAgICAgb3V0IHBhcmFtZXRlciBpbnN0ZWFkIG9mIGEgcG9pbnRlci4KKyAgICAgICAgKFJl c291cmNlSGFuZGxlQ2xpZW50KTogUmVtb3ZlIHNvdXAgc3BlY2lmaWMgY29kZS4KKyAgICAgICAg KiBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlSW50ZXJuYWwuaDoKKyAgICAgICAgKFdl YkNvcmU6OlJlc291cmNlSGFuZGxlSW50ZXJuYWw6OlJlc291cmNlSGFuZGxlSW50ZXJuYWwpOiBS ZW5hbWUKKyAgICAgICAgbV9idWZmZXIgYW5kIG1fYnVmZmVyU2l6ZSBhcyBtX3JlYWRCdWZmZXJQ dHIgYW5kIG1fcmVhZEJ1ZmZlclNpemUKKyAgICAgICAgYW5kIGFkZCBtX3JlYWRCdWZmZXIgdG8g YmUgdXNlZCBhcyBkZWZhdWx0IHJlYWQgYnVmZmVyLgorICAgICAgICAqIHBsYXRmb3JtL25ldHdv cmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3Vy Y2VIYW5kbGU6OmVuc3VyZVJlYWRCdWZmZXIpOiBIZWxwZXIgZnVuY3Rpb24gdG8KKyAgICAgICAg bWFrZSB1c3JlIHdlIGhhdmUgYSByZWFkIGJ1ZmZlciBiZWZvcmUgYSByZWFkIG9wZXJhdGlvbi4g SXQgZmlyc3QKKyAgICAgICAgY2hlY2tzIGlmIHRoZSBjbGllbnQgcHJvdmlkZXMgYSBidWZmZXIg YW5kIGlmIGl0IGRvZXNuJ3QgaXQKKyAgICAgICAgY3JlYXRlcyBvciByZXVzZXMgdGhlIGRlZmF1 bHQgYnVmZmVyLgorICAgICAgICAoV2ViQ29yZTo6cmVkaXJlY3RTa2lwQ2FsbGJhY2spOiBDYWxs IGVuc3VyZVJlYWRCdWZmZXIoKSBhbmQgYWRhcHQKKyAgICAgICAgdG8gdmFyaWFibGUgbmFtZSBj aGFuZ2VzLgorICAgICAgICAoV2ViQ29yZTo6Y2xlYW51cFNvdXBSZXF1ZXN0T3BlcmF0aW9uKTog QWRhcHQgdG8gdmFyaWFibGUgbmFtZQorICAgICAgICBjaGFuZ2VzLgorICAgICAgICAoV2ViQ29y ZTo6bmV4dE11bHRpcGFydFJlc3BvbnNlUGFydENhbGxiYWNrKTogQ2FsbAorICAgICAgICBlbnN1 cmVSZWFkQnVmZmVyKCkgYW5kIGFkYXB0IHRvIHZhcmlhYmxlIG5hbWUgY2hhbmdlcy4KKyAgICAg ICAgKFdlYkNvcmU6OnNlbmRSZXF1ZXN0Q2FsbGJhY2spOiBEaXR0by4KKyAgICAgICAgKFdlYkNv cmU6OnJlYWRDYWxsYmFjayk6IERpdHRvLgorCiAyMDEzLTA0LTI4ICBDaHJpc3RvcGhlIER1bWV6 ICA8Y2guZHVtZXpAc2lzYS5zYW1zdW5nLmNvbT4KIAogICAgICAgICBHZXQgcmlkIG9mIFtDYWxs YmFja10gSURMIGV4dGVuZGVkIGF0dHJpYnV0ZSBmb3IgcGFyYW1ldGVycwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL1dlYktpdFdlYlNvdXJj ZUdTdHJlYW1lci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFt ZXIvV2ViS2l0V2ViU291cmNlR1N0cmVhbWVyLmNwcAppbmRleCA1YjJhZGYyLi43NjNiMWUwIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2Vi S2l0V2ViU291cmNlR1N0cmVhbWVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9nc3RyZWFtZXIvV2ViS2l0V2ViU291cmNlR1N0cmVhbWVyLmNwcApAQCAtNTMsNyAr NTMsNyBAQCBjbGFzcyBTdHJlYW1pbmdDbGllbnQgOiBwdWJsaWMgUmVzb3VyY2VIYW5kbGVDbGll bnQgewogICAgICAgICB2aXJ0dWFsIHZvaWQgd2lsbFNlbmRSZXF1ZXN0KFJlc291cmNlSGFuZGxl KiwgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYpOwogICAgICAgICB2 aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZVJlc3BvbnNlKFJlc291cmNlSGFuZGxlKiwgY29uc3QgUmVz b3VyY2VSZXNwb25zZSYpOwogCi0gICAgICAgIHZpcnR1YWwgY2hhciogZ2V0QnVmZmVyKGludCwg aW50Kik7CisgICAgICAgIHZpcnR1YWwgY2hhciogZ2V0T3JDcmVhdGVSZWFkQnVmZmVyKHNpemVf dCByZXF1ZXN0ZWRTaXplLCBzaXplX3QmIGFjdHVhbFNpemUpOwogCiAgICAgICAgIHZpcnR1YWwg dm9pZCBkaWRSZWNlaXZlRGF0YShSZXNvdXJjZUhhbmRsZSosIGNvbnN0IGNoYXIqLCBpbnQsIGlu dCk7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRGaW5pc2hMb2FkaW5nKFJlc291cmNlSGFuZGxl KiwgZG91YmxlIC8qZmluaXNoVGltZSovKTsKQEAgLTkyNCw3ICs5MjQsNyBAQCB2b2lkIFN0cmVh bWluZ0NsaWVudDo6ZGlkUmVjZWl2ZURhdGEoUmVzb3VyY2VIYW5kbGUqIGhhbmRsZSwgY29uc3Qg Y2hhciogZGF0YSwgaQogICAgICAgICBHU1RfRUxFTUVOVF9FUlJPUihtX3NyYywgQ09SRSwgRkFJ TEVELCAoMCksICgwKSk7CiB9CiAKLWNoYXIqIFN0cmVhbWluZ0NsaWVudDo6Z2V0QnVmZmVyKGlu dCByZXF1ZXN0ZWRTaXplLCBpbnQqIGFjdHVhbFNpemUpCitjaGFyKiBTdHJlYW1pbmdDbGllbnQ6 OmdldE9yQ3JlYXRlUmVhZEJ1ZmZlcihzaXplX3QgcmVxdWVzdGVkU2l6ZSwgc2l6ZV90JiBhY3R1 YWxTaXplKQogewogICAgIFdlYktpdFdlYlNyY1ByaXZhdGUqIHByaXYgPSBtX3NyYy0+cHJpdjsK IApAQCAtOTM4LDcgKzkzOCw3IEBAIGNoYXIqIFN0cmVhbWluZ0NsaWVudDo6Z2V0QnVmZmVyKGlu dCByZXF1ZXN0ZWRTaXplLCBpbnQqIGFjdHVhbFNpemUpCiAKICAgICBwcml2LT5idWZmZXIgPSBh ZG9wdEdSZWYoYnVmZmVyKTsKIAotICAgICphY3R1YWxTaXplID0gZ2V0R3N0QnVmZmVyU2l6ZShi dWZmZXIpOworICAgIGFjdHVhbFNpemUgPSBnZXRHc3RCdWZmZXJTaXplKGJ1ZmZlcik7CiAgICAg cmV0dXJuIGdldEdzdEJ1ZmZlckRhdGFQb2ludGVyKGJ1ZmZlcik7CiB9CiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaAppbmRleCA4ZWZiNjdi Li5iYjRmZTViIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jl c291cmNlSGFuZGxlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNv dXJjZUhhbmRsZS5oCkBAIC0xNjcsNiArMTY3LDcgQEAgcHVibGljOgogICAgIHZvaWQgc2VuZFBl bmRpbmdSZXF1ZXN0KCk7CiAgICAgYm9vbCBzaG91bGRVc2VDcmVkZW50aWFsU3RvcmFnZSgpOwog ICAgIGJvb2wgY2FuY2VsbGVkT3JDbGllbnRsZXNzKCk7CisgICAgdm9pZCBlbnN1cmVSZWFkQnVm ZmVyKCk7CiAgICAgc3RhdGljIFNvdXBTZXNzaW9uKiBkZWZhdWx0U2Vzc2lvbigpOwogICAgIHN0 YXRpYyB1aW50NjRfdCBnZXRTb3VwUmVxdWVzdEluaXRpYXRpbmdQYWdlSUQoU291cFJlcXVlc3Qq KTsKICAgICBzdGF0aWMgdm9pZCBzZXRIb3N0QWxsb3dzQW55SFRUUFNDZXJ0aWZpY2F0ZShjb25z dCBTdHJpbmcmKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv UmVzb3VyY2VIYW5kbGVDbGllbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9SZXNvdXJjZUhhbmRsZUNsaWVudC5jcHAKaW5kZXggNDcwYWJjZi4uNjM5N2Q3MCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZUNsaWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRs ZUNsaWVudC5jcHAKQEAgLTI5LDI3ICsyOSwxNCBAQAogI2luY2x1ZGUgIlJlc291cmNlSGFuZGxl LmgiCiAjaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCiAKLSNpZiBVU0UoU09VUCkKLSNpbmNsdWRl IDxnbGliLmg+Ci0jZW5kaWYKLQogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBSZXNvdXJjZUhhbmRs ZUNsaWVudDo6UmVzb3VyY2VIYW5kbGVDbGllbnQoKQotI2lmIFVTRShTT1VQKQotICAgIDogbV9i dWZmZXIoMCkKLSNlbmRpZgogewogfQogCiBSZXNvdXJjZUhhbmRsZUNsaWVudDo6flJlc291cmNl SGFuZGxlQ2xpZW50KCkKIHsKLSNpZiBVU0UoU09VUCkKLSAgICBpZiAobV9idWZmZXIpIHsKLSAg ICAgICAgZ19mcmVlKG1fYnVmZmVyKTsKLSAgICAgICAgbV9idWZmZXIgPSAwOwotICAgIH0KLSNl bmRpZgogfQogCiB2b2lkIFJlc291cmNlSGFuZGxlQ2xpZW50Ojp3aWxsU2VuZFJlcXVlc3RBc3lu YyhSZXNvdXJjZUhhbmRsZSogaGFuZGxlLCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3Qs IGNvbnN0IFJlc291cmNlUmVzcG9uc2UmIC8qcmVkaXJlY3RSZXNwb25zZSovKQpAQCAtODYsMTYg KzczLDQgQEAgdm9pZCBSZXNvdXJjZUhhbmRsZUNsaWVudDo6ZGlkUmVjZWl2ZUJ1ZmZlcihSZXNv dXJjZUhhbmRsZSogaGFuZGxlLCBQYXNzUmVmUHRyPFMKICAgICBkaWRSZWNlaXZlRGF0YShoYW5k bGUsIGJ1ZmZlci0+ZGF0YSgpLCBidWZmZXItPnNpemUoKSwgZW5jb2RlZERhdGFMZW5ndGgpOwog fQogCi0jaWYgVVNFKFNPVVApCi1jaGFyKiBSZXNvdXJjZUhhbmRsZUNsaWVudDo6Z2V0QnVmZmVy KGludCByZXF1ZXN0ZWRMZW5ndGgsIGludCogYWN0dWFsTGVuZ3RoKQotewotICAgICphY3R1YWxM ZW5ndGggPSByZXF1ZXN0ZWRMZW5ndGg7Ci0KLSAgICBpZiAoIW1fYnVmZmVyKQotICAgICAgICBt X2J1ZmZlciA9IHN0YXRpY19jYXN0PGNoYXIqPihnX21hbGxvYyhyZXF1ZXN0ZWRMZW5ndGgpKTsK LQotICAgIHJldHVybiBtX2J1ZmZlcjsKLX0KLSNlbmRpZgotCiB9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlQ2xpZW50LmggYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlQ2xpZW50LmgKaW5kZXgg MDY5M2NkMi4uNGQwM2Y5MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9SZXNvdXJjZUhhbmRsZUNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvUmVzb3VyY2VIYW5kbGVDbGllbnQuaApAQCAtOTksNyArOTksNyBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAjZW5kaWYKIAogI2lmIFVTRShTT1VQKQotICAgICAgICB2aXJ0dWFsIGNo YXIqIGdldEJ1ZmZlcihpbnQgcmVxdWVzdGVkTGVuZ3RoLCBpbnQqIGFjdHVhbExlbmd0aCk7Cisg ICAgICAgIHZpcnR1YWwgY2hhciogZ2V0T3JDcmVhdGVSZWFkQnVmZmVyKHNpemVfdCByZXF1ZXN0 ZWRMZW5ndGgsIHNpemVfdCYgYWN0dWFsTGVuZ3RoKSB7IHJldHVybiAwOyB9CiAjZW5kaWYKIAog ICAgICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkVXNlQ3JlZGVudGlhbFN0b3JhZ2UoUmVzb3VyY2VI YW5kbGUqKSB7IHJldHVybiBmYWxzZTsgfQpAQCAtMTIyLDEwICsxMjIsNiBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgYm9vbCBzaG91bGRDYWNoZVJlc3BvbnNlKFJlc291 cmNlSGFuZGxlKiwgQ0ZDYWNoZWRVUkxSZXNwb25zZVJlZikgeyByZXR1cm4gdHJ1ZTsgfQogI2Vu ZGlmCiAKLSNpZiBVU0UoU09VUCkKLXByaXZhdGU6Ci0gICAgICAgIGNoYXIqIG1fYnVmZmVyOwot I2VuZGlmCiAgICAgfTsKIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9SZXNvdXJjZUhhbmRsZUludGVybmFsLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlSW50ZXJuYWwuaAppbmRleCA1OTVmNTE3Li5lZWU2ZmRl IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFu ZGxlSW50ZXJuYWwuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291 cmNlSGFuZGxlSW50ZXJuYWwuaApAQCAtNDgsNiArNDgsNyBAQAogCiAjaWYgVVNFKFNPVVApCiAj aW5jbHVkZSA8bGlic291cC9zb3VwLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5o PgogI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KIGNsYXNzIEZyYW1lOwogI2VuZGlm CkBAIC0xMTAsOCArMTExLDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2VuZGlmCiAjaWYgVVNF KFNPVVApCiAgICAgICAgICAgICAsIG1fY2FuY2VsbGVkKGZhbHNlKQotICAgICAgICAgICAgLCBt X2J1ZmZlcigwKQotICAgICAgICAgICAgLCBtX2J1ZmZlclNpemUoMCkKKyAgICAgICAgICAgICwg bV9yZWFkQnVmZmVyUHRyKDApCisgICAgICAgICAgICAsIG1fcmVhZEJ1ZmZlclNpemUoMCkKICAg ICAgICAgICAgICwgbV9ib2R5U2l6ZSgwKQogICAgICAgICAgICAgLCBtX2JvZHlEYXRhU2VudCgw KQogICAgICAgICAgICAgLCBtX3JlZGlyZWN0Q291bnQoMCkKQEAgLTE5OCw4ICsxOTksOSBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIEdSZWZQdHI8R0NhbmNlbGxhYmxlPiBtX2NhbmNl bGxhYmxlOwogICAgICAgICBHUmVmUHRyPEdBc3luY1Jlc3VsdD4gbV9kZWZlcnJlZFJlc3VsdDsK ICAgICAgICAgR1JlZlB0cjxHU291cmNlPiBtX3RpbWVvdXRTb3VyY2U7Ci0gICAgICAgIGNoYXIq IG1fYnVmZmVyOwotICAgICAgICBpbnQgbV9idWZmZXJTaXplOworICAgICAgICBHT3duUHRyPGNo YXI+IG1fcmVhZEJ1ZmZlcjsKKyAgICAgICAgY2hhciogbV9yZWFkQnVmZmVyUHRyOworICAgICAg ICBzaXplX3QgbV9yZWFkQnVmZmVyU2l6ZTsKICAgICAgICAgdW5zaWduZWQgbG9uZyBtX2JvZHlT aXplOwogICAgICAgICB1bnNpZ25lZCBsb25nIG1fYm9keURhdGFTZW50OwogICAgICAgICBTb3Vw U2Vzc2lvbiogc291cFNlc3Npb24oKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKaW5kZXggNjIxNDBh Mi4uOGVhOGE4YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9z b3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKQEAgLTc2LDggKzc2LDYgQEAKIAog bmFtZXNwYWNlIFdlYkNvcmUgewogCi0jZGVmaW5lIFJFQURfQlVGRkVSX1NJWkUgODE5MgotCiBp bmxpbmUgc3RhdGljIHZvaWQgc291cExvZ1ByaW50ZXIoU291cExvZ2dlciosIFNvdXBMb2dnZXJM b2dMZXZlbCwgY2hhciBkaXJlY3Rpb24sIGNvbnN0IGNoYXIqIGRhdGEsIGdwb2ludGVyKQogewog I2lmIExPR19ESVNBQkxFRApAQCAtMzA0LDYgKzMwMiwyOCBAQCBib29sIFJlc291cmNlSGFuZGxl OjpjYW5jZWxsZWRPckNsaWVudGxlc3MoKQogICAgIHJldHVybiBnZXRJbnRlcm5hbCgpLT5tX2Nh bmNlbGxlZDsKIH0KIAordm9pZCBSZXNvdXJjZUhhbmRsZTo6ZW5zdXJlUmVhZEJ1ZmZlcigpCit7 CisgICAgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbCogZCA9IGdldEludGVybmFsKCk7CisKKyAgICBz dGF0aWMgY29uc3Qgc2l6ZV90IGRlZmF1bHRSZWFkQnVmZmVyU2l6ZSA9IDgxOTI7CisgICAgc2l6 ZV90IGJ1ZmZlclNpemU7CisgICAgY2hhciogYnVmZmVyUHRyID0gY2xpZW50KCktPmdldE9yQ3Jl YXRlUmVhZEJ1ZmZlcihkZWZhdWx0UmVhZEJ1ZmZlclNpemUsIGJ1ZmZlclNpemUpOworICAgIGlm IChidWZmZXJQdHIpIHsKKyAgICAgICAgZC0+bV9yZWFkQnVmZmVyLmNsZWFyKCk7CisgICAgICAg IGQtPm1fcmVhZEJ1ZmZlclB0ciA9IGJ1ZmZlclB0cjsKKyAgICAgICAgZC0+bV9yZWFkQnVmZmVy U2l6ZSA9IGJ1ZmZlclNpemU7CisgICAgfSBlbHNlIGlmIChkLT5tX3JlYWRCdWZmZXJTaXplIDwg ZGVmYXVsdFJlYWRCdWZmZXJTaXplKSB7CisgICAgICAgIGQtPm1fcmVhZEJ1ZmZlci5zZXQoc3Rh dGljX2Nhc3Q8Y2hhcio+KGdfbWFsbG9jKGRlZmF1bHRSZWFkQnVmZmVyU2l6ZSkpKTsKKyAgICAg ICAgZC0+bV9yZWFkQnVmZmVyUHRyID0gZC0+bV9yZWFkQnVmZmVyLmdldCgpOworICAgICAgICBk LT5tX3JlYWRCdWZmZXJTaXplID0gZGVmYXVsdFJlYWRCdWZmZXJTaXplOworICAgIH0gZWxzZQor ICAgICAgICBkLT5tX3JlYWRCdWZmZXJQdHIgPSBkLT5tX3JlYWRCdWZmZXIuZ2V0KCk7CisKKyAg ICBBU1NFUlQoZC0+bV9yZWFkQnVmZmVyUHRyKTsKKyAgICBBU1NFUlQoZC0+bV9yZWFkQnVmZmVy U2l6ZSk7Cit9CisKIHN0YXRpYyBib29sIGlzQXV0aGVudGljYXRpb25GYWlsdXJlU3RhdHVzQ29k ZShpbnQgaHR0cFN0YXR1c0NvZGUpCiB7CiAgICAgcmV0dXJuIGh0dHBTdGF0dXNDb2RlID09IFNP VVBfU1RBVFVTX1BST1hZX0FVVEhFTlRJQ0FUSU9OX1JFUVVJUkVEIHx8IGh0dHBTdGF0dXNDb2Rl ID09IFNPVVBfU1RBVFVTX1VOQVVUSE9SSVpFRDsKQEAgLTUxMiw4ICs1MzIsOCBAQCBzdGF0aWMg dm9pZCByZWRpcmVjdFNraXBDYWxsYmFjayhHT2JqZWN0KiwgR0FzeW5jUmVzdWx0KiBhc3luY1Jl c3VsdCwgZ3BvaW50ZXIgZAogICAgIH0KIAogICAgIGlmIChieXRlc1NraXBwZWQgPiAwKSB7Ci0g ICAgICAgIGQtPm1fYnVmZmVyID0gaGFuZGxlLT5jbGllbnQoKS0+Z2V0QnVmZmVyKFJFQURfQlVG RkVSX1NJWkUsICZkLT5tX2J1ZmZlclNpemUpOwotICAgICAgICBnX2lucHV0X3N0cmVhbV9yZWFk X2FzeW5jKGQtPm1faW5wdXRTdHJlYW0uZ2V0KCksIGQtPm1fYnVmZmVyLCBkLT5tX2J1ZmZlclNp emUsIEdfUFJJT1JJVFlfREVGQVVMVCwKKyAgICAgICAgaGFuZGxlLT5lbnN1cmVSZWFkQnVmZmVy KCk7CisgICAgICAgIGdfaW5wdXRfc3RyZWFtX3JlYWRfYXN5bmMoZC0+bV9pbnB1dFN0cmVhbS5n ZXQoKSwgZC0+bV9yZWFkQnVmZmVyUHRyLCBkLT5tX3JlYWRCdWZmZXJTaXplLCBHX1BSSU9SSVRZ X0RFRkFVTFQsCiAgICAgICAgICAgICBkLT5tX2NhbmNlbGxhYmxlLmdldCgpLCByZWRpcmVjdFNr aXBDYWxsYmFjaywgaGFuZGxlLmdldCgpKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KQEAgLTU1 NCwxMCArNTc0LDEwIEBAIHN0YXRpYyB2b2lkIGNsZWFudXBTb3VwUmVxdWVzdE9wZXJhdGlvbihS ZXNvdXJjZUhhbmRsZSogaGFuZGxlLCBib29sIGlzRGVzdHJveWluCiAgICAgICAgIGQtPm1fc291 cE1lc3NhZ2UuY2xlYXIoKTsKICAgICB9CiAKLSAgICBpZiAoZC0+bV9idWZmZXIpIHsKLSAgICAg ICAgZC0+bV9idWZmZXIgPSAwOwotICAgICAgICBkLT5tX2J1ZmZlclNpemUgPSAwOwotICAgIH0K KyAgICBpZiAoZC0+bV9yZWFkQnVmZmVyUHRyKQorICAgICAgICBkLT5tX3JlYWRCdWZmZXJQdHIg PSAwOworICAgIGlmICghZC0+bV9yZWFkQnVmZmVyKQorICAgICAgICBkLT5tX3JlYWRCdWZmZXJT aXplID0gMDsKIAogICAgIGlmIChkLT5tX3RpbWVvdXRTb3VyY2UpIHsKICAgICAgICAgZ19zb3Vy Y2VfZGVzdHJveShkLT5tX3RpbWVvdXRTb3VyY2UuZ2V0KCkpOwpAQCAtNjI3LDggKzY0Nyw4IEBA IHN0YXRpYyB2b2lkIG5leHRNdWx0aXBhcnRSZXNwb25zZVBhcnRDYWxsYmFjayhHT2JqZWN0KiAv KnNvdXJjZSovLCBHQXN5bmNSZXN1bHQqCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBk LT5tX2J1ZmZlciA9IGhhbmRsZS0+Y2xpZW50KCktPmdldEJ1ZmZlcihSRUFEX0JVRkZFUl9TSVpF LCAmZC0+bV9idWZmZXJTaXplKTsKLSAgICBnX2lucHV0X3N0cmVhbV9yZWFkX2FzeW5jKGQtPm1f aW5wdXRTdHJlYW0uZ2V0KCksIGQtPm1fYnVmZmVyLCBkLT5tX2J1ZmZlclNpemUsCisgICAgaGFu ZGxlLT5lbnN1cmVSZWFkQnVmZmVyKCk7CisgICAgZ19pbnB1dF9zdHJlYW1fcmVhZF9hc3luYyhk LT5tX2lucHV0U3RyZWFtLmdldCgpLCBkLT5tX3JlYWRCdWZmZXJQdHIsIGQtPm1fcmVhZEJ1ZmZl clNpemUsCiAgICAgICAgIEdfUFJJT1JJVFlfREVGQVVMVCwgZC0+bV9jYW5jZWxsYWJsZS5nZXQo KSwgcmVhZENhbGxiYWNrLCBoYW5kbGUuZ2V0KCkpOwogfQogCkBAIC02NTgsNyArNjc4LDcgQEAg c3RhdGljIHZvaWQgc2VuZFJlcXVlc3RDYWxsYmFjayhHT2JqZWN0KiwgR0FzeW5jUmVzdWx0KiBy ZXN1bHQsIGdwb2ludGVyIGRhdGEpCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBBU1NF UlQoIWQtPm1fYnVmZmVyKTsKKyAgICBBU1NFUlQoIWQtPm1fcmVhZEJ1ZmZlclB0cik7CiAKICAg ICBpZiAoc291cE1lc3NhZ2UpIHsKICAgICAgICAgaWYgKFNPVVBfU1RBVFVTX0lTX1JFRElSRUNU SU9OKHNvdXBNZXNzYWdlLT5zdGF0dXNfY29kZSkgJiYgc2hvdWxkUmVkaXJlY3QoaGFuZGxlLmdl dCgpKSkgewpAQCAtNjY2LDggKzY4Niw4IEBAIHN0YXRpYyB2b2lkIHNlbmRSZXF1ZXN0Q2FsbGJh Y2soR09iamVjdCosIEdBc3luY1Jlc3VsdCogcmVzdWx0LCBncG9pbnRlciBkYXRhKQogICAgICAg ICAgICAgLy8gV2UgdXNlIHJlYWRfYXN5bmMoKSByYXRoZXIgdGhhbiBza2lwX2FzeW5jKCkgdG8g d29yayBhcm91bmQKICAgICAgICAgICAgIC8vIGh0dHBzOi8vYnVnemlsbGEuZ25vbWUub3JnL3No b3dfYnVnLmNnaT9pZD02OTE0ODkgdW50aWwgd2UgY2FuCiAgICAgICAgICAgICAvLyBkZXBlbmQg b24gZ2xpYiA+IDIuMzUuNAotICAgICAgICAgICAgZC0+bV9idWZmZXIgPSBoYW5kbGUtPmNsaWVu dCgpLT5nZXRCdWZmZXIoUkVBRF9CVUZGRVJfU0laRSwgJmQtPm1fYnVmZmVyU2l6ZSk7Ci0gICAg ICAgICAgICBnX2lucHV0X3N0cmVhbV9yZWFkX2FzeW5jKGQtPm1faW5wdXRTdHJlYW0uZ2V0KCks IGQtPm1fYnVmZmVyLCBkLT5tX2J1ZmZlclNpemUsIEdfUFJJT1JJVFlfREVGQVVMVCwKKyAgICAg ICAgICAgIGhhbmRsZS0+ZW5zdXJlUmVhZEJ1ZmZlcigpOworICAgICAgICAgICAgZ19pbnB1dF9z dHJlYW1fcmVhZF9hc3luYyhkLT5tX2lucHV0U3RyZWFtLmdldCgpLCBkLT5tX3JlYWRCdWZmZXJQ dHIsIGQtPm1fcmVhZEJ1ZmZlclNpemUsIEdfUFJJT1JJVFlfREVGQVVMVCwKICAgICAgICAgICAg ICAgICBkLT5tX2NhbmNlbGxhYmxlLmdldCgpLCByZWRpcmVjdFNraXBDYWxsYmFjaywgaGFuZGxl LmdldCgpKTsKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQpAQCAtNzA3LDkgKzcyNyw5 IEBAIHN0YXRpYyB2b2lkIHNlbmRSZXF1ZXN0Q2FsbGJhY2soR09iamVjdCosIEdBc3luY1Jlc3Vs dCogcmVzdWx0LCBncG9pbnRlciBkYXRhKQogCiAgICAgZC0+bV9pbnB1dFN0cmVhbSA9IGlucHV0 U3RyZWFtOwogCi0gICAgZC0+bV9idWZmZXIgPSBoYW5kbGUtPmNsaWVudCgpLT5nZXRCdWZmZXIo UkVBRF9CVUZGRVJfU0laRSwgJmQtPm1fYnVmZmVyU2l6ZSk7Ci0gICAgZ19pbnB1dF9zdHJlYW1f cmVhZF9hc3luYyhkLT5tX2lucHV0U3RyZWFtLmdldCgpLCBkLT5tX2J1ZmZlciwgZC0+bV9idWZm ZXJTaXplLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR19QUklPUklUWV9ERUZBVUxU LCBkLT5tX2NhbmNlbGxhYmxlLmdldCgpLCByZWFkQ2FsbGJhY2ssIGhhbmRsZS5nZXQoKSk7Cisg ICAgaGFuZGxlLT5lbnN1cmVSZWFkQnVmZmVyKCk7CisgICAgZ19pbnB1dF9zdHJlYW1fcmVhZF9h c3luYyhkLT5tX2lucHV0U3RyZWFtLmdldCgpLCBkLT5tX3JlYWRCdWZmZXJQdHIsIGQtPm1fcmVh ZEJ1ZmZlclNpemUsCisgICAgICAgIEdfUFJJT1JJVFlfREVGQVVMVCwgZC0+bV9jYW5jZWxsYWJs ZS5nZXQoKSwgcmVhZENhbGxiYWNrLCBoYW5kbGUuZ2V0KCkpOwogfQogCiBzdGF0aWMgYm9vbCBh ZGRGaWxlVG9Tb3VwTWVzc2FnZUJvZHkoU291cE1lc3NhZ2UqIG1lc3NhZ2UsIGNvbnN0IFN0cmlu ZyYgZmlsZU5hbWVTdHJpbmcsIHNpemVfdCBvZmZzZXQsIHNpemVfdCBsZW5ndGhUb1NlbmQsIHVu c2lnbmVkIGxvbmcmIHRvdGFsQm9keVNpemUpCkBAIC0xMzIxLDcgKzEzNDEsNyBAQCBzdGF0aWMg dm9pZCByZWFkQ2FsbGJhY2soR09iamVjdCosIEdBc3luY1Jlc3VsdCogYXN5bmNSZXN1bHQsIGdw b2ludGVyIGRhdGEpCiAgICAgLy8gSXQncyBtYW5kYXRvcnkgdG8gaGF2ZSBzZW50IGEgcmVzcG9u c2UgYmVmb3JlIHNlbmRpbmcgZGF0YQogICAgIEFTU0VSVCghZC0+bV9yZXNwb25zZS5pc051bGwo KSk7CiAKLSAgICBoYW5kbGUtPmNsaWVudCgpLT5kaWRSZWNlaXZlRGF0YShoYW5kbGUuZ2V0KCks IGQtPm1fYnVmZmVyLCBieXRlc1JlYWQsIGJ5dGVzUmVhZCk7CisgICAgaGFuZGxlLT5jbGllbnQo KS0+ZGlkUmVjZWl2ZURhdGEoaGFuZGxlLmdldCgpLCBkLT5tX3JlYWRCdWZmZXJQdHIsIGJ5dGVz UmVhZCwgYnl0ZXNSZWFkKTsKIAogICAgIC8vIGRpZFJlY2VpdmVEYXRhIG1heSBjYW5jZWwgdGhl IGxvYWQsIHdoaWNoIG1heSByZWxlYXNlIHRoZSBsYXN0IHJlZmVyZW5jZS4KICAgICBpZiAoaGFu ZGxlLT5jYW5jZWxsZWRPckNsaWVudGxlc3MoKSkgewpAQCAtMTMyOSw5ICsxMzQ5LDkgQEAgc3Rh dGljIHZvaWQgcmVhZENhbGxiYWNrKEdPYmplY3QqLCBHQXN5bmNSZXN1bHQqIGFzeW5jUmVzdWx0 LCBncG9pbnRlciBkYXRhKQogICAgICAgICByZXR1cm47CiAgICAgfQogCi0gICAgZC0+bV9idWZm ZXIgPSBoYW5kbGUtPmNsaWVudCgpLT5nZXRCdWZmZXIoUkVBRF9CVUZGRVJfU0laRSwgJmQtPm1f YnVmZmVyU2l6ZSk7Ci0gICAgZ19pbnB1dF9zdHJlYW1fcmVhZF9hc3luYyhkLT5tX2lucHV0U3Ry ZWFtLmdldCgpLCBkLT5tX2J1ZmZlciwgZC0+bV9idWZmZXJTaXplLCBHX1BSSU9SSVRZX0RFRkFV TFQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkLT5tX2NhbmNlbGxhYmxlLmdldCgp LCByZWFkQ2FsbGJhY2ssIGhhbmRsZS5nZXQoKSk7CisgICAgaGFuZGxlLT5lbnN1cmVSZWFkQnVm ZmVyKCk7CisgICAgZ19pbnB1dF9zdHJlYW1fcmVhZF9hc3luYyhkLT5tX2lucHV0U3RyZWFtLmdl dCgpLCBkLT5tX3JlYWRCdWZmZXJQdHIsIGQtPm1fcmVhZEJ1ZmZlclNpemUsIEdfUFJJT1JJVFlf REVGQVVMVCwKKyAgICAgICAgZC0+bV9jYW5jZWxsYWJsZS5nZXQoKSwgcmVhZENhbGxiYWNrLCBo YW5kbGUuZ2V0KCkpOwogfQogCiBzdGF0aWMgZ2Jvb2xlYW4gcmVxdWVzdFRpbWVvdXRDYWxsYmFj ayhncG9pbnRlciBkYXRhKQo=