96067 2012-09-06 22:21:35 -0700 [chromium] Adaptively throttle texture uploads 2013-03-12 20:45:55 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED INVALID P2 Normal --- 1 brianderson brianderson cc-bugs dglazkov jamesr nduca peter+ews reveman sam webkit.review.bot oldest_to_newest 714107 0 brianderson 2012-09-06 22:21:35 -0700 [chromium] Adaptively throttle texture uploads 714114 1 162672 brianderson 2012-09-06 22:31:49 -0700 Created attachment 162672 Patch 714116 2 brianderson 2012-09-06 22:32:59 -0700 Looking for early feedback on this patch. It will need to be tested to make sure it's tuned to run well on a variety of platforms... 714185 3 162672 peter+ews 2012-09-06 23:44:38 -0700 Comment on attachment 162672 Patch Attachment 162672 did not pass cr-android-ews (chromium-android): Output: http://queues.webkit.org/results/13785301 714381 4 162672 nduca 2012-09-07 04:15:16 -0700 Comment on attachment 162672 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162672&action=review > Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:62 > +void ThrottledTextureUploader::Query::end(unsigned pixelsUploaded) bit odd that this is on end rather than begin... any good reason? > Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:131 > + return m_averagePixelsPerSecond; Should we do this in mpix so the numbers dont overflow? > Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:169 > + m_averagePixelsPerSecond = (m_averagePixelsPerSecond * (uploadAverageWindow-1) + I dont quite understand this math. Is this a weighted average of some sort? Why not m_average * decay + pps*(1-decay)? I'm not very good at this stuff so maybe I'm missing something. Also, should we use a proper window or a percentile or something? If a texture upload is unlucky to get descheduled, i expect it'll hugely sway any sort of mean. That then forces a very slow decay... ~shrug~ would a histogram make sense? > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:38 > +static const size_t pixelsPerTexture = 256 * 256; this isn't guaranteed... > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:60 > +double CCTextureUpdateController::averagePixelsPerSecond() why this accessor? > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:84 > + if (m_uploader->pendingUploadGroups() < targetUploadGroups) { Is there a simple version of this we can try fist? E.g. just look at the average upload time and, if its less than 0.05 for a 256, then do 4x the current count. Period. No control scheme more than that. I'm a big believer ni starting with something simple that we then can refine... 714596 5 162672 reveman 2012-09-07 09:29:01 -0700 Comment on attachment 162672 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162672&action=review >> Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:169 >> + m_averagePixelsPerSecond = (m_averagePixelsPerSecond * (uploadAverageWindow-1) + > > I dont quite understand this math. Is this a weighted average of some sort? Why not m_average * decay + pps*(1-decay)? I'm not very good at this stuff so maybe I'm missing something. > > Also, should we use a proper window or a percentile or something? If a texture upload is unlucky to get descheduled, i expect it'll hugely sway any sort of mean. That then forces a very slow decay... ~shrug~ would a histogram make sense? The occasional unlucky upload time was a problem last time I played with this. I was getting better results when averaging the slope of the linear interpolant between each recorded value. > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:111 > + m_textureUpdatesPerTick = ceil(texturesPerSecond * m_textureUpdateTickPeriod * .25 + epsilon); I don't like the idea of setting m_textureUpdatesPerTick to less than the value returned by maxPartialTextureUpdates(). We need to allow uploading of maxPartialTextureUpdates textures not to break partial uploads and that would make the timing estimates here incorrect. To get the most out of increasing m_textureUpdatesPerTick we should also allow more partial updates on the main thread. > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:146 > + if (fullUploadCount && (count - fullUploadCount) < queue->partialUploadSize()) I guess this is to compensate for the fact that m_textureUpdatesPerTick can now be less than maxPartialTextureUpdates. Can we instead adjust maxPartialTextureUpdates so that queue->partialUploadSize() is greater than count? > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h:85 > + size_t m_sequentialUpdateCount; It's not obvious to me what this member variable is for. Maybe add a comment? 714737 6 162672 brianderson 2012-09-07 10:53:28 -0700 Comment on attachment 162672 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162672&action=review >> Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:62 >> +void ThrottledTextureUploader::Query::end(unsigned pixelsUploaded) > > bit odd that this is on end rather than begin... any good reason? ThrottledTextureUploader doesn't have the information available to pass to Query::begin. ThrottledTextureUploader accumulates the pixels for each upload and then passes it into Query::end. We could require the caller of ThrottledTextureUploader::beginUploads to pass in that information, but that would require two passes over the pending uploads. >> Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:131 >> + return m_averagePixelsPerSecond; > > Should we do this in mpix so the numbers dont overflow? Yeah, I'm a little worried about overflow as well. Will come up with something better. >>> Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:169 >>> + m_averagePixelsPerSecond = (m_averagePixelsPerSecond * (uploadAverageWindow-1) + >> >> I dont quite understand this math. Is this a weighted average of some sort? Why not m_average * decay + pps*(1-decay)? I'm not very good at this stuff so maybe I'm missing something. >> >> Also, should we use a proper window or a percentile or something? If a texture upload is unlucky to get descheduled, i expect it'll hugely sway any sort of mean. That then forces a very slow decay... ~shrug~ would a histogram make sense? > > The occasional unlucky upload time was a problem last time I played with this. I was getting better results when averaging the slope of the linear interpolant between each recorded value. uploadAverageWindow's naming is a little missleading since it is more of a decay, where decay = (window-1)/window in Nat's equation. Something a little smarter will probably be good. Can I leverage any of the work you guys have already done? >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:38 >> +static const size_t pixelsPerTexture = 256 * 256; > > this isn't guaranteed... Yeah, I wasn't sure how to get that information initially. Can the full upload texture sizes change on the fly? Otherwise, I could probably just record the last value of a full texture upload. >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:60 >> +double CCTextureUpdateController::averagePixelsPerSecond() > > why this accessor? Pretty much for the TODO part. If we don't get to the TODO in this patch, I'll remove it. >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:84 >> + if (m_uploader->pendingUploadGroups() < targetUploadGroups) { > > Is there a simple version of this we can try fist? E.g. just look at the average upload time and, if its less than 0.05 for a 256, then do 4x the current count. Period. No control scheme more than that. I'm a big believer ni starting with something simple that we then can refine... Yeah, we can start off with something more simple. I picked a lot of constants in here somewhat arbitrarily and it'll take a lot more time tuning those constants than it would take to tune something simpler. We do have control over the tick rate and the number of textures to upload though, so maybe we can have both of those depend on the average upload time. >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:111 >> + m_textureUpdatesPerTick = ceil(texturesPerSecond * m_textureUpdateTickPeriod * .25 + epsilon); > > I don't like the idea of setting m_textureUpdatesPerTick to less than the value returned by maxPartialTextureUpdates(). We need to allow uploading of maxPartialTextureUpdates textures not to break partial uploads and that would make the timing estimates here incorrect. > > To get the most out of increasing m_textureUpdatesPerTick we should also allow more partial updates on the main thread. Thanks for pointing that out. I see now that CCLayerTreeHost::requestPartialTextureUpdate() actually uses this information to limit the number of partial updates per frame. >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:146 >> + if (fullUploadCount && (count - fullUploadCount) < queue->partialUploadSize()) > > I guess this is to compensate for the fact that m_textureUpdatesPerTick can now be less than maxPartialTextureUpdates. Can we instead adjust maxPartialTextureUpdates so that queue->partialUploadSize() is greater than count? As a first pass for this patch, I think it'll be easiest to do what you suggest. Will we ever want to have CCLayerTreeHost::requestPartialTextureUpdate() take into account a dynamically changing maxPartialTextureUpdates? >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h:85 >> + size_t m_sequentialUpdateCount; > > It's not obvious to me what this member variable is for. Maybe add a comment? It's supposed to be the number of texture uploads so far since the updateMoreTextures that initiated the first texture upload. It is used to avoid making any adjustments during our first upload since we won't have any feedback yet, which I'm realizing may not necessarily be true now. Will need to rethink it. Also, I think there are some race conditions with vsync ticks that might throw off the way I update this variable. 714816 7 162672 webkit.review.bot 2012-09-07 11:52:47 -0700 Comment on attachment 162672 Patch Attachment 162672 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/13771874 714836 8 reveman 2012-09-07 12:15:22 -0700 (In reply to comment #6) > (From update of attachment 162672 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=162672&action=review > > >> Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:62 > >> +void ThrottledTextureUploader::Query::end(unsigned pixelsUploaded) > > > > bit odd that this is on end rather than begin... any good reason? > > ThrottledTextureUploader doesn't have the information available to pass to Query::begin. ThrottledTextureUploader accumulates the pixels for each upload and then passes it into Query::end. We could require the caller of ThrottledTextureUploader::beginUploads to pass in that information, but that would require two passes over the pending uploads. > > >> Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:131 > >> + return m_averagePixelsPerSecond; > > > > Should we do this in mpix so the numbers dont overflow? > > Yeah, I'm a little worried about overflow as well. Will come up with something better. > > >>> Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:169 > >>> + m_averagePixelsPerSecond = (m_averagePixelsPerSecond * (uploadAverageWindow-1) + > >> > >> I dont quite understand this math. Is this a weighted average of some sort? Why not m_average * decay + pps*(1-decay)? I'm not very good at this stuff so maybe I'm missing something. > >> > >> Also, should we use a proper window or a percentile or something? If a texture upload is unlucky to get descheduled, i expect it'll hugely sway any sort of mean. That then forces a very slow decay... ~shrug~ would a histogram make sense? > > > > The occasional unlucky upload time was a problem last time I played with this. I was getting better results when averaging the slope of the linear interpolant between each recorded value. > > uploadAverageWindow's naming is a little missleading since it is more of a decay, where decay = (window-1)/window in Nat's equation. > > Something a little smarter will probably be good. Can I leverage any of the work you guys have already done? what I played with was even more complicated. I'd prefer if we started with something really simple, like using the median over the last 10 full update groups. > > >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:38 > >> +static const size_t pixelsPerTexture = 256 * 256; > > > > this isn't guaranteed... > > Yeah, I wasn't sure how to get that information initially. Can the full upload texture sizes change on the fly? Otherwise, I could probably just record the last value of a full texture upload. > > >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:60 > >> +double CCTextureUpdateController::averagePixelsPerSecond() > > > > why this accessor? > > Pretty much for the TODO part. If we don't get to the TODO in this patch, I'll remove it. > > >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:84 > >> + if (m_uploader->pendingUploadGroups() < targetUploadGroups) { > > > > Is there a simple version of this we can try fist? E.g. just look at the average upload time and, if its less than 0.05 for a 256, then do 4x the current count. Period. No control scheme more than that. I'm a big believer ni starting with something simple that we then can refine... > > Yeah, we can start off with something more simple. I picked a lot of constants in here somewhat arbitrarily and it'll take a lot more time tuning those constants than it would take to tune something simpler. > > We do have control over the tick rate and the number of textures to upload though, so maybe we can have both of those depend on the average upload time. > > >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:111 > >> + m_textureUpdatesPerTick = ceil(texturesPerSecond * m_textureUpdateTickPeriod * .25 + epsilon); > > > > I don't like the idea of setting m_textureUpdatesPerTick to less than the value returned by maxPartialTextureUpdates(). We need to allow uploading of maxPartialTextureUpdates textures not to break partial uploads and that would make the timing estimates here incorrect. > > > > To get the most out of increasing m_textureUpdatesPerTick we should also allow more partial updates on the main thread. > > Thanks for pointing that out. I see now that CCLayerTreeHost::requestPartialTextureUpdate() actually uses this information to limit the number of partial updates per frame. > > >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:146 > >> + if (fullUploadCount && (count - fullUploadCount) < queue->partialUploadSize()) > > > > I guess this is to compensate for the fact that m_textureUpdatesPerTick can now be less than maxPartialTextureUpdates. Can we instead adjust maxPartialTextureUpdates so that queue->partialUploadSize() is greater than count? > > As a first pass for this patch, I think it'll be easiest to do what you suggest. > > Will we ever want to have CCLayerTreeHost::requestPartialTextureUpdate() take into account a dynamically changing maxPartialTextureUpdates? I think it makes sense to do so. The value from maxPartialTextureUpdates could be passed to beginFrame. > > >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h:85 > >> + size_t m_sequentialUpdateCount; > > > > It's not obvious to me what this member variable is for. Maybe add a comment? > > It's supposed to be the number of texture uploads so far since the updateMoreTextures that initiated the first texture upload. It is used to avoid making any adjustments during our first upload since we won't have any feedback yet, which I'm realizing may not necessarily be true now. Will need to rethink it. Also, I think there are some race conditions with vsync ticks that might throw off the way I update this variable. Do we need to be able to adjust upload time estimates during a commit? Maybe things would be simpler if we only adjusted the texture upload estimates in between frames? That's also the only time we can adjust maxPartialTextureUpdates. 715246 9 nduca 2012-09-07 20:51:31 -0700 > Do we need to be able to adjust upload time estimates during a commit? Maybe things would be simpler if we only adjusted the texture upload estimates in between frames? That's also the only time we can adjust maxPartialTextureUpdates. This sounds like a very good simplification. 717806 10 163494 brianderson 2012-09-11 18:44:23 -0700 Created attachment 163494 Patch 717813 11 163494 brianderson 2012-09-11 18:55:45 -0700 Comment on attachment 163494 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=163494&action=review Here is an update that addresses most of the comments from the previous patch. Still needs some work. > Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.cpp:128 > +double ThrottledTextureUploader::estimatedPixelsPerSecond() This uses the median now. > Source/WebCore/platform/graphics/chromium/ThrottledTextureUploader.h:30 > +#include <deque> Would like to avoid using two deque classes in the same file, but couldn't figure out how to sort wtf/Deque > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:496 > + m_maxPartialTextureUpdates = std::min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates()); m_settings.maxPartialTextureUpdates is now treated as read only. m_proxy->maxPartialTextureUpdates() is the current limit the uploader has communicated to the main thread. m_maxPartialTextureUpdates is the limit we will use for the next frame. > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:39 > +static const size_t pixelsPerTexture = 256 * 256; Still not sure how to do this better... > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:60 > void CCTextureUpdateController::updateTextures(CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader, CCTextureUpdateQueue* queue, size_t count) I restructured the logic here a bit to make sure we don't flush until after we've inserted the query. I had noticed in some traces that the queries were being executed a long time after the actual end of the uploads because of the extra flushes. > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:211 > + (size_t) ceil(texturesPerSecond * m_tickPeriod)); This maintains a minimum update count of 12, to keep the previous behavior for slow systems. Faster systems will upload more textures though. > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:250 > + m_client->setMaxPartialTextureUpdatesOnImplThread(maxPartialTextureUpdates()); This is where the impl thread communicates to the main thread the current maxPartialTextureUpdates. > Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp:861 > + m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::setMaxPartialTextureUpdates, max)); This is where setMaxPartialTextureUpdates makes the jump to the main thread. 717864 12 163494 reveman 2012-09-11 20:26:27 -0700 Comment on attachment 163494 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=163494&action=review This is looking pretty good. A few ideas below. > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:496 > + m_maxPartialTextureUpdates = std::min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates()); How about we pass the maxPartialTextureUpdates value to CCLayerTreeHost::updateLayers as a parameter instead and remove the CCProxy::maxPartialTextureUpdates() function? > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:-77 > - ASSERT(queue->partialUploadSize() <= count); Could we keep this assert in some form? It's useful in preventing us from introducing a partial update regression in this or a future patch. > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:199 > +void CCTextureUpdateController::updateTextureCountAndTickPeriod(double timeBeforeVsync) I think this looks more complicated than it is. Could it somehow be restructured to early out instead of having this tree of if/else branches? Maybe it makes more sense to have a "size_t nextTextureUpdateCount(double timeBeforeVSync)" function instead? Also how is e.g. 1 full update + 11 partial updates handled? That's currently all done in one 4ms update interval but it looks like this patch might be doing it less efficiently. Or am I missing something? > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h:41 > + virtual void setMaxPartialTextureUpdatesOnImplThread(size_t) = 0; How about getting maxPartialTextureUpdates from the uploader instead? It seems like all the state needed to compute that is already maintained there. Btw, I don't think this function should have "OnImplThread" in the name, that's a CCThreadProxy specific detail. > Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h:80 > + double m_tickPeriod; You don't seem to be using this. > Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp:861 > + m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::setMaxPartialTextureUpdates, max)); Would it be easier to pass this value to the main thread with CCThreadProxy::beginFrame? Changing it at a different time shouldn't be allowed anyhow. 718657 13 163494 brianderson 2012-09-12 13:21:11 -0700 Comment on attachment 163494 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=163494&action=review >>> Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:496 >>> + m_maxPartialTextureUpdates = std::min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates()); >> >> m_settings.maxPartialTextureUpdates is now treated as read only. >> m_proxy->maxPartialTextureUpdates() is the current limit the uploader has communicated to the main thread. >> m_maxPartialTextureUpdates is the limit we will use for the next frame. > > How about we pass the maxPartialTextureUpdates value to CCLayerTreeHost::updateLayers as a parameter instead and remove the CCProxy::maxPartialTextureUpdates() function? I like. >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:-77 >> - ASSERT(queue->partialUploadSize() <= count); > > Could we keep this assert in some form? It's useful in preventing us from introducing a partial update regression in this or a future patch. We can keep it if we synchronize maxPartialTextureUpdates on both the main and impl threads. This patch doesn't synchronize them and I'm not sure if it'll be more complicated than it's worth yet. >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:199 >> +void CCTextureUpdateController::updateTextureCountAndTickPeriod(double timeBeforeVsync) > > I think this looks more complicated than it is. Could it somehow be restructured to early out instead of having this tree of if/else branches? Maybe it makes more sense to have a "size_t nextTextureUpdateCount(double timeBeforeVSync)" function instead? > > Also how is e.g. 1 full update + 11 partial updates handled? That's currently all done in one 4ms update interval but it looks like this patch might be doing it less efficiently. Or am I missing something? >I think this looks more complicated than it is. Will restructure and rename. > Also how is e.g. 1 full update + 11 partial updates handled? Good catch. You are correct, although that was not my intent. This function will still set m_textureUpdatesPerTick to 12, however I need to fix CCTextureUpdateController::updateTextures so it doesn't early out. >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h:41 >> + virtual void setMaxPartialTextureUpdatesOnImplThread(size_t) = 0; > > How about getting maxPartialTextureUpdates from the uploader instead? It seems like all the state needed to compute that is already maintained there. Btw, I don't think this function should have "OnImplThread" in the name, that's a CCThreadProxy specific detail. I put this function here instead of in the uploader because, although the uploader had all the state to compute the bandwidth, the CCTextureUpdateController had the state to know *when* to compute the bandwidth. Will change the when to be in CCThreadProxy::scheduledActionBeginFrame. Will remove OnImplThread suffix. >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h:80 >> + double m_tickPeriod; > > You don't seem to be using this. It is used but isn't really a variable anymore, so I will remove it. >>> Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp:861 >>> + m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::setMaxPartialTextureUpdates, max)); >> >> This is where setMaxPartialTextureUpdates makes the jump to the main thread. > > Would it be easier to pass this value to the main thread with CCThreadProxy::beginFrame? Changing it at a different time shouldn't be allowed anyhow. I initially tried to do that, but it seemed more complicated than it's worth. Upon further inspection, it doesn't look too bad. 718837 14 reveman 2012-09-12 15:57:00 -0700 (In reply to comment #13) > (From update of attachment 163494 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=163494&action=review > > >>> Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:496 > >>> + m_maxPartialTextureUpdates = std::min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates()); > >> > >> m_settings.maxPartialTextureUpdates is now treated as read only. > >> m_proxy->maxPartialTextureUpdates() is the current limit the uploader has communicated to the main thread. > >> m_maxPartialTextureUpdates is the limit we will use for the next frame. > > > > How about we pass the maxPartialTextureUpdates value to CCLayerTreeHost::updateLayers as a parameter instead and remove the CCProxy::maxPartialTextureUpdates() function? > > I like. > > >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:-77 > >> - ASSERT(queue->partialUploadSize() <= count); > > > > Could we keep this assert in some form? It's useful in preventing us from introducing a partial update regression in this or a future patch. > > We can keep it if we synchronize maxPartialTextureUpdates on both the main and impl threads. This patch doesn't synchronize them and I'm not sure if it'll be more complicated than it's worth yet. Hm, when processing partial updates the impl thread need to be passing "count >= queue->partialUploadSize()" as partial updates can't be split into two groups. What's the case when this ASSERT is causing problems? I don't think I understand why it can't just be left as is. > > >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp:199 > >> +void CCTextureUpdateController::updateTextureCountAndTickPeriod(double timeBeforeVsync) > > > > I think this looks more complicated than it is. Could it somehow be restructured to early out instead of having this tree of if/else branches? Maybe it makes more sense to have a "size_t nextTextureUpdateCount(double timeBeforeVSync)" function instead? > > > > Also how is e.g. 1 full update + 11 partial updates handled? That's currently all done in one 4ms update interval but it looks like this patch might be doing it less efficiently. Or am I missing something? > > >I think this looks more complicated than it is. > Will restructure and rename. > > > Also how is e.g. 1 full update + 11 partial updates handled? > Good catch. You are correct, although that was not my intent. This function will still set m_textureUpdatesPerTick to 12, however I need to fix CCTextureUpdateController::updateTextures so it doesn't early out. > > >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h:41 > >> + virtual void setMaxPartialTextureUpdatesOnImplThread(size_t) = 0; > > > > How about getting maxPartialTextureUpdates from the uploader instead? It seems like all the state needed to compute that is already maintained there. Btw, I don't think this function should have "OnImplThread" in the name, that's a CCThreadProxy specific detail. > > I put this function here instead of in the uploader because, although the uploader had all the state to compute the bandwidth, the CCTextureUpdateController had the state to know *when* to compute the bandwidth. > > Will change the when to be in CCThreadProxy::scheduledActionBeginFrame. > Will remove OnImplThread suffix. > > >> Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h:80 > >> + double m_tickPeriod; > > > > You don't seem to be using this. > > It is used but isn't really a variable anymore, so I will remove it. > > >>> Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp:861 > >>> + m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::setMaxPartialTextureUpdates, max)); > >> > >> This is where setMaxPartialTextureUpdates makes the jump to the main thread. > > > > Would it be easier to pass this value to the main thread with CCThreadProxy::beginFrame? Changing it at a different time shouldn't be allowed anyhow. > > I initially tried to do that, but it seemed more complicated than it's worth. Upon further inspection, it doesn't look too bad. I think it might be cleaner. On a more general note, I'm not fully convinced that adjusting the number of texture updates per tick is better than adjusting the tick rate. Both approaches have pros and cons. Before we get into too much detail, can we add some details about the two different methods and some rational for picking one over the other to the texture upload strategy doc? 719811 15 brianderson 2012-09-13 12:49:23 -0700 Moving review to https://codereview.chromium.org/10916292 because of GTFO. 854030 16 sam 2013-03-12 20:45:46 -0700 I don't think this bug is relevant anymore. 162672 2012-09-06 22:31:49 -0700 2012-09-11 18:44:20 -0700 Patch bug-96067-20120906223129.patch text/plain 20985 brianderson U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3Njk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWY2NGExNWYwODM4NWFk YjM5OGE5OGZmMDBjNTJjYTFjZmZkN2EzNS4uNjc1MTMzNDA2ODgzNGU3MGYwMjBmZjE1YWEyM2Q5 NTgzODkxYjAzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDYxIEBACisyMDEyLTA5LTA2ICBCcmlh biBBbmRlcnNvbiAgPGJyaWFuZGVyc29uQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21p dW1dIEFkYXB0aXZlbHkgdGhyb3R0bGUgdGV4dHVyZSB1cGxvYWRzCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05NjA2NworCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdlIG5lZWQgYWRhcHRpdmUgdGV4dHVyZSB1 cGxvYWRpbmcgYmVjYXVzZSB3ZSBydW4gb24gYSB3aWRlIHZhcmlldHkKKyAgICAgICAgb2Ygc3lz dGVtcyBhbmQgYSBvbmUgc2l6ZSBmaXRzIGFsbCBwb2xpY3kgd2lsbCBub3Qgd29yay4KKyAgICAg ICAgQmFzZWQgb24gYSBzcGVjaWZpYyB0YXJnZXQgbGF0ZW5jeSwgdGhpcyBwYXRjaCBhZGFwdGl2 ZWx5IGFkanVzdHMKKyAgICAgICAgdGhlIHVwbG9hZGVyJ3MgdGljayByYXRlIGFuZCBndWVzc2Vz IHRoZSBudW1iZXIgb2YgdGV4dHVyZXMgaXQgY2FuCisgICAgICAgIHVwbG9hZCB3aXRoaW4gdGhh dCBwZXJpb2QuCisgICAgICAgIEFsc28gYmFzZWQgb24gdGhlIHRhcmdldCBsYXRlbmN5LCB3ZSBh bGxvdyBtb3JlIHVwbG9hZCBiYXRjaGVzCisgICAgICAgIHRvIGJlIGluIGZsaWdodCBmb3IgZmFz dGVyIHRpY2sgcmF0ZXMuCisgICAgICAgIFJ1bnRpbWVzIG9mIHByZXZpb3VzIHRleHR1cmUgdXBs b2FkcyBvbiB0aGUgZ3B1IHByb2Nlc3MgYXJlIHVzZWQKKyAgICAgICAgdG8gZXN0aW1hdGUgdGhl IHJ1bnRpbWUgb2YgZnV0dXJlIHVwbG9hZHMuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChPT1BT ISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UZXh0dXJlVXBsb2Fk ZXIuaDoKKyAgICAgICAgKFRleHR1cmVVcGxvYWRlcik6CisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6UXVlcnk6OlF1ZXJ5KToKKyAgICAgICAg KFdlYkNvcmU6OlRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6UXVlcnk6OmVuZCk6CisgICAgICAg IChXZWJDb3JlOjpUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OlF1ZXJ5Ojp3YWl0KToKKyAgICAg ICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6VGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVy OjpRdWVyeTo6dmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6VGhyb3R0bGVkVGV4dHVyZVVwbG9h ZGVyOjpRdWVyeTo6cGl4ZWxzVXBsb2FkZWQpOgorICAgICAgICAoV2ViQ29yZTo6VGhyb3R0bGVk VGV4dHVyZVVwbG9hZGVyOjpUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXIpOgorICAgICAgICAoV2Vi Q29yZTo6VGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjppc0J1c3kpOgorICAgICAgICAoV2ViQ29y ZTo6VGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjpwZW5kaW5nVXBsb2FkR3JvdXBzKToKKyAgICAg ICAgKFdlYkNvcmU6OlRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6YXZlcmFnZVBpeGVsc1BlclNl Y29uZCk6CisgICAgICAgIChXZWJDb3JlOjpUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OmJlZ2lu VXBsb2Fkcyk6CisgICAgICAgIChXZWJDb3JlOjpUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OmVu ZFVwbG9hZHMpOgorICAgICAgICAoV2ViQ29yZTo6VGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjp1 cGxvYWRUZXh0dXJlKToKKyAgICAgICAgKFdlYkNvcmU6OlRocm90dGxlZFRleHR1cmVVcGxvYWRl cjo6cHJvY2Vzc1F1ZXJpZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L1Rocm90dGxlZFRleHR1cmVVcGxvYWRlci5oOgorICAgICAgICAoVGhyb3R0bGVkVGV4dHVyZVVw bG9hZGVyKToKKyAgICAgICAgKFF1ZXJ5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9VbnRocm90dGxlZFRleHR1cmVVcGxvYWRlci5oOgorICAgICAgICAoV2ViQ29yZTo6 VW50aHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OnBlbmRpbmdVcGxvYWRHcm91cHMpOgorICAgICAg ICAoV2ViQ29yZTo6VW50aHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OmF2ZXJhZ2VQaXhlbHNQZXJT ZWNvbmQpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGV4dHVy ZVVwZGF0ZUNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q0NUZXh0dXJlVXBkYXRl Q29udHJvbGxlcjo6bWF4UGFydGlhbFRleHR1cmVVcGRhdGVzKToKKyAgICAgICAgKFdlYkNvcmUp OgorICAgICAgICAoV2ViQ29yZTo6Q0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6YXZlcmFnZVBp eGVsc1BlclNlY29uZCk6CisgICAgICAgIChXZWJDb3JlOjpDQ1RleHR1cmVVcGRhdGVDb250cm9s bGVyOjp1cGRhdGVUZXh0dXJlQ291bnRBbmRSYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkNDVGV4 dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OnVwZGF0ZVRleHR1cmVzKToKKyAgICAgICAgKFdlYkNvcmU6 OkNDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OkNDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXIpOgor ICAgICAgICAoV2ViQ29yZTo6Q0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRlTW9yZVRl eHR1cmVzKToKKyAgICAgICAgKFdlYkNvcmU6OkNDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6Om9u VGltZXJGaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVy Ojp1cGRhdGVNb3JlVGV4dHVyZXNUaW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkNDVGV4dHVyZVVw ZGF0ZUNvbnRyb2xsZXI6OnVwZGF0ZU1vcmVUZXh0dXJlc1NpemUpOgorICAgICAgICAoV2ViQ29y ZTo6Q0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRlTW9yZVRleHR1cmVzSWZFbm91Z2hU aW1lUmVtYWluaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkNDVGV4dHVyZVVwZGF0ZUNvbnRyb2xs ZXI6OnVwZGF0ZU1vcmVUZXh0dXJlc05vdyk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vY2MvQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlci5oOgorICAgICAgICAoQ0NUZXh0 dXJlVXBkYXRlQ29udHJvbGxlcik6CisKIDIwMTItMDktMDUgIFRpbSBIb3J0b24gIDx0aW1vdGh5 X2hvcnRvbkBhcHBsZS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZDsgcmV2ZXJ0IGEgY2hhbmdl IHRvIFNjcm9sbGluZ1RyZWVOb2RlTWFjIHdoaWNoIGFjY2lkZW50YWxseQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZVVwbG9hZGVy LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UZXh0dXJlVXBs b2FkZXIuaAppbmRleCAwYTg2MTYxMmUzNTlhZmQ2ZTQyZDkwNjExZTU2N2U0YzM2MjJlNjc2Li45 ZDAxN2VmNTYwODJjNjA0ZWY4ZjA4OTQ0MGVmN2U1NGY5MTY5Y2I0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UZXh0dXJlVXBsb2FkZXIuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UZXh0dXJlVXBs b2FkZXIuaApAQCAtNDAsNiArNDAsMTAgQEAgcHVibGljOgogICAgIHZpcnR1YWwgflRleHR1cmVV cGxvYWRlcigpIHsgfQogCiAgICAgdmlydHVhbCBib29sIGlzQnVzeSgpID0gMDsKKyAgICB2aXJ0 dWFsIHNpemVfdCBwZW5kaW5nVXBsb2FkR3JvdXBzKCkgPSAwOworCisgICAgLy8gUmV0dXJucyBv dXIgdGhyb3VnaHB1dCBvbiB0aGUgR1BVIHByb2Nlc3MKKyAgICB2aXJ0dWFsIGRvdWJsZSBhdmVy YWdlUGl4ZWxzUGVyU2Vjb25kKCkgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBiZWdpblVwbG9hZHMo KSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGVuZFVwbG9hZHMoKSA9IDA7CiAgICAgdmlydHVhbCB2 b2lkIHVwbG9hZFRleHR1cmUoQ0NSZXNvdXJjZVByb3ZpZGVyKiwgUGFyYW1ldGVycykgPSAwOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGhy b3R0bGVkVGV4dHVyZVVwbG9hZGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1Rocm90dGxlZFRleHR1cmVVcGxvYWRlci5jcHAKaW5kZXggYjgyZWQyYjk3 YzY1OTA2MzI1ZmVkODNiMzkxMDhkOTMzYmJkMjk5NC4uYjU2YmJjYzc1ODViNTEyYWFiZjI2NWI2 ZjM3Y2IxYTcwZjhlZWVhMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaHJvdHRsZWRUZXh0dXJlVXBsb2Fk ZXIuY3BwCkBAIC0zMiw3ICszMiwxMCBAQAogbmFtZXNwYWNlIHsKIAogLy8gTnVtYmVyIG9mIHBl bmRpbmcgdGV4dHVyZSB1cGRhdGUgcXVlcmllcyB0byBhbGxvdy4KLXN0YXRpYyBjb25zdCBzaXpl X3QgbWF4UGVuZGluZ1F1ZXJpZXMgPSAyOworc3RhdGljIGNvbnN0IHNpemVfdCBtYXhQZW5kaW5n UXVlcmllcyA9IDQ7CisKKy8vIEhvdyBtYW55IHVwbG9hZHMgdG8gYXZlcmFnZSBvdmVyCitzdGF0 aWMgY29uc3Qgc2l6ZV90IHVwbG9hZEF2ZXJhZ2VXaW5kb3cgPSAxMDsKIAogfSAvLyBhbm9ueW1v dXMgbmFtZXNwYWNlCiAKQEAgLTQxLDYgKzQ0LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogVGhy b3R0bGVkVGV4dHVyZVVwbG9hZGVyOjpRdWVyeTo6UXVlcnkoV2ViS2l0OjpXZWJHcmFwaGljc0Nv bnRleHQzRCogY29udGV4dCkKICAgICA6IG1fY29udGV4dChjb250ZXh0KQogICAgICwgbV9xdWVy eUlkKDApCisgICAgLCBtX3BpeGVsc1VwbG9hZGVkKDApCiB7CiAgICAgbV9xdWVyeUlkID0gbV9j b250ZXh0LT5jcmVhdGVRdWVyeUVYVCgpOwogfQpAQCAtNTUsOSArNTksMTAgQEAgdm9pZCBUaHJv dHRsZWRUZXh0dXJlVXBsb2FkZXI6OlF1ZXJ5OjpiZWdpbigpCiAgICAgbV9jb250ZXh0LT5iZWdp blF1ZXJ5RVhUKEV4dGVuc2lvbnMzRENocm9taXVtOjpDT01NQU5EU19JU1NVRURfQ0hST01JVU0s IG1fcXVlcnlJZCk7CiB9CiAKLXZvaWQgVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjpRdWVyeTo6 ZW5kKCkKK3ZvaWQgVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjpRdWVyeTo6ZW5kKHVuc2lnbmVk IHBpeGVsc1VwbG9hZGVkKQogewogICAgIG1fY29udGV4dC0+ZW5kUXVlcnlFWFQoRXh0ZW5zaW9u czNEQ2hyb21pdW06OkNPTU1BTkRTX0lTU1VFRF9DSFJPTUlVTSk7CisgICAgbV9waXhlbHNVcGxv YWRlZCA9IHBpeGVsc1VwbG9hZGVkOwogfQogCiBib29sIFRocm90dGxlZFRleHR1cmVVcGxvYWRl cjo6UXVlcnk6OmlzUGVuZGluZygpCkBAIC02OSwxOSArNzQsMzUgQEAgYm9vbCBUaHJvdHRsZWRU ZXh0dXJlVXBsb2FkZXI6OlF1ZXJ5Ojppc1BlbmRpbmcoKQogCiB2b2lkIFRocm90dGxlZFRleHR1 cmVVcGxvYWRlcjo6UXVlcnk6OndhaXQoKQogeworICAgIHZhbHVlKCk7CisgICAgcmV0dXJuOwor fQorCit1bnNpZ25lZCBUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OlF1ZXJ5Ojp2YWx1ZSgpCit7 CiAgICAgdW5zaWduZWQgcmVzdWx0OwogICAgIG1fY29udGV4dC0+Z2V0UXVlcnlPYmplY3R1aXZF WFQobV9xdWVyeUlkLCBFeHRlbnNpb25zM0RDaHJvbWl1bTo6UVVFUllfUkVTVUxUX0VYVCwgJnJl c3VsdCk7CisgICAgcmV0dXJuIHJlc3VsdDsKK30KKwordW5zaWduZWQgVGhyb3R0bGVkVGV4dHVy ZVVwbG9hZGVyOjpRdWVyeTo6cGl4ZWxzVXBsb2FkZWQoKQoreworICAgIHJldHVybiBtX3BpeGVs c1VwbG9hZGVkOwogfQogCiBUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OlRocm90dGxlZFRleHR1 cmVVcGxvYWRlcihXZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0KQogICAgIDog bV9jb250ZXh0KGNvbnRleHQpCiAgICAgLCBtX21heFBlbmRpbmdRdWVyaWVzKG1heFBlbmRpbmdR dWVyaWVzKQorICAgICwgbV9hdmVyYWdlUGl4ZWxzUGVyU2Vjb25kKDAuMCkKKyAgICAsIG1fcGl4 ZWxzVXBsb2FkZWQoMCkKIHsKIH0KIAogVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjpUaHJvdHRs ZWRUZXh0dXJlVXBsb2FkZXIoV2ViS2l0OjpXZWJHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwg c2l6ZV90IHBlbmRpbmdVcGxvYWRMaW1pdCkKICAgICA6IG1fY29udGV4dChjb250ZXh0KQogICAg ICwgbV9tYXhQZW5kaW5nUXVlcmllcyhwZW5kaW5nVXBsb2FkTGltaXQpCisgICAgLCBtX2F2ZXJh Z2VQaXhlbHNQZXJTZWNvbmQoMC4wKQorICAgICwgbV9waXhlbHNVcGxvYWRlZCgwKQogewogICAg IEFTU0VSVChtX2NvbnRleHQpOwogfQpAQCAtOTIsMjAgKzExMywyOCBAQCBUaHJvdHRsZWRUZXh0 dXJlVXBsb2FkZXI6On5UaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXIoKQogCiBib29sIFRocm90dGxl ZFRleHR1cmVVcGxvYWRlcjo6aXNCdXN5KCkKIHsKKyAgICByZXR1cm4gcGVuZGluZ1VwbG9hZEdy b3VwcygpID09IG1fbWF4UGVuZGluZ1F1ZXJpZXM7Cit9CisKK3NpemVfdCBUaHJvdHRsZWRUZXh0 dXJlVXBsb2FkZXI6OnBlbmRpbmdVcGxvYWRHcm91cHMoKQorewogICAgIHByb2Nlc3NRdWVyaWVz KCk7CiAKLSAgICBpZiAoIW1fYXZhaWxhYmxlUXVlcmllcy5pc0VtcHR5KCkpCi0gICAgICAgIHJl dHVybiBmYWxzZTsKKyAgICBpZiAobV9wZW5kaW5nUXVlcmllcy5zaXplKCkgIT0gbV9tYXhQZW5k aW5nUXVlcmllcyAmJiBtX2F2YWlsYWJsZVF1ZXJpZXMuaXNFbXB0eSgpKQorICAgICAgICBtX2F2 YWlsYWJsZVF1ZXJpZXMuYXBwZW5kKFF1ZXJ5OjpjcmVhdGUobV9jb250ZXh0KSk7CiAKLSAgICBp ZiAobV9wZW5kaW5nUXVlcmllcy5zaXplKCkgPT0gbV9tYXhQZW5kaW5nUXVlcmllcykKLSAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgcmV0dXJuIG1fcGVuZGluZ1F1ZXJpZXMuc2l6ZSgpOworfQog Ci0gICAgbV9hdmFpbGFibGVRdWVyaWVzLmFwcGVuZChRdWVyeTo6Y3JlYXRlKG1fY29udGV4dCkp OwotICAgIHJldHVybiBmYWxzZTsKK2RvdWJsZSBUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OmF2 ZXJhZ2VQaXhlbHNQZXJTZWNvbmQoKQoreworICAgIHJldHVybiBtX2F2ZXJhZ2VQaXhlbHNQZXJT ZWNvbmQ7CiB9CiAKIHZvaWQgVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjpiZWdpblVwbG9hZHMo KQogeworICAgIG1fcGl4ZWxzVXBsb2FkZWQgPSAwOworCiAgICAgLy8gV2FpdCBmb3IgcXVlcnkg dG8gYmVjb21lIGF2YWlsYWJsZS4KICAgICB3aGlsZSAoaXNCdXN5KCkpCiAgICAgICAgIG1fcGVu ZGluZ1F1ZXJpZXMuZmlyc3QoKS0+d2FpdCgpOwpAQCAtMTE2LDEyICsxNDUsMTMgQEAgdm9pZCBU aHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OmJlZ2luVXBsb2FkcygpCiAKIHZvaWQgVGhyb3R0bGVk VGV4dHVyZVVwbG9hZGVyOjplbmRVcGxvYWRzKCkKIHsKLSAgICBtX2F2YWlsYWJsZVF1ZXJpZXMu Zmlyc3QoKS0+ZW5kKCk7CisgICAgbV9hdmFpbGFibGVRdWVyaWVzLmZpcnN0KCktPmVuZChtX3Bp eGVsc1VwbG9hZGVkKTsKICAgICBtX3BlbmRpbmdRdWVyaWVzLmFwcGVuZChtX2F2YWlsYWJsZVF1 ZXJpZXMudGFrZUZpcnN0KCkpOwogfQogCiB2b2lkIFRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6 dXBsb2FkVGV4dHVyZShDQ1Jlc291cmNlUHJvdmlkZXIqIHJlc291cmNlUHJvdmlkZXIsIFBhcmFt ZXRlcnMgdXBsb2FkKQogeworICAgIG1fcGl4ZWxzVXBsb2FkZWQgKz0gdXBsb2FkLnNvdXJjZVJl Y3Qud2lkdGgoKSAqIHVwbG9hZC5zb3VyY2VSZWN0LndpZHRoKCk7CiAgICAgdXBsb2FkLnRleHR1 cmUtPnVwZGF0ZVJlY3QocmVzb3VyY2VQcm92aWRlciwgdXBsb2FkLnNvdXJjZVJlY3QsIHVwbG9h ZC5kZXN0T2Zmc2V0KTsKIH0KIApAQCAtMTMxLDYgKzE2MSwxNSBAQCB2b2lkIFRocm90dGxlZFRl eHR1cmVVcGxvYWRlcjo6cHJvY2Vzc1F1ZXJpZXMoKQogICAgICAgICBpZiAobV9wZW5kaW5nUXVl cmllcy5maXJzdCgpLT5pc1BlbmRpbmcoKSkKICAgICAgICAgICAgIGJyZWFrOwogCisgICAgICAg IHVuc2lnbmVkIHVzRWxhcHNlZCA9IG1fcGVuZGluZ1F1ZXJpZXMuZmlyc3QoKS0+dmFsdWUoKTsK KyAgICAgICAgZG91YmxlIHBpeGVsc1BlclNlY29uZCA9IG1fcGVuZGluZ1F1ZXJpZXMuZmlyc3Qo KS0+cGl4ZWxzVXBsb2FkZWQoKSAvICh1c0VsYXBzZWQgKiAxZS02KTsKKyAgICAgICAgaWYgKG1f YXZlcmFnZVBpeGVsc1BlclNlY29uZCA9PSAwLjApCisgICAgICAgICAgICBtX2F2ZXJhZ2VQaXhl bHNQZXJTZWNvbmQgPSBwaXhlbHNQZXJTZWNvbmQ7CisgICAgICAgIGVsc2UgeworICAgICAgICAg ICAgbV9hdmVyYWdlUGl4ZWxzUGVyU2Vjb25kID0gKG1fYXZlcmFnZVBpeGVsc1BlclNlY29uZCAq ICh1cGxvYWRBdmVyYWdlV2luZG93LTEpICsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBwaXhlbHNQZXJTZWNvbmQpIC8gdXBsb2FkQXZlcmFnZVdpbmRvdzsKKyAgICAg ICAgfQorCiAgICAgICAgIG1fYXZhaWxhYmxlUXVlcmllcy5hcHBlbmQobV9wZW5kaW5nUXVlcmll cy50YWtlRmlyc3QoKSk7CiAgICAgfQogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyLmggYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaHJvdHRsZWRUZXh0dXJlVXBs b2FkZXIuaAppbmRleCAzNjE0NjhmYzgyZWY1M2VlY2JhNDg0NGNlYzIxYzQwNTYyOGI2MDZiLi5l YWZlNmI1YWQ5NzIzMWZlMzdkYzZlYjQ3NTUzYzdiNTUxZGE2MjEzIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaHJvdHRsZWRUZXh0dXJlVXBs b2FkZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U aHJvdHRsZWRUZXh0dXJlVXBsb2FkZXIuaApAQCAtNDksNiArNDksOCBAQCBwdWJsaWM6CiAgICAg dmlydHVhbCB+VGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyKCk7CiAKICAgICB2aXJ0dWFsIGJvb2wg aXNCdXN5KCkgT1ZFUlJJREU7CisgICAgdmlydHVhbCBzaXplX3QgcGVuZGluZ1VwbG9hZEdyb3Vw cygpIE9WRVJSSURFOworICAgIHZpcnR1YWwgZG91YmxlIGF2ZXJhZ2VQaXhlbHNQZXJTZWNvbmQo KSBPVkVSUklERTsKICAgICB2aXJ0dWFsIHZvaWQgYmVnaW5VcGxvYWRzKCkgT1ZFUlJJREU7CiAg ICAgdmlydHVhbCB2b2lkIGVuZFVwbG9hZHMoKSBPVkVSUklERTsKICAgICB2aXJ0dWFsIHZvaWQg dXBsb2FkVGV4dHVyZShDQ1Jlc291cmNlUHJvdmlkZXIqLCBQYXJhbWV0ZXJzKSBPVkVSUklERTsK QEAgLTYxLDE1ICs2MywxOCBAQCBwcml2YXRlOgogICAgICAgICB2aXJ0dWFsIH5RdWVyeSgpOwog CiAgICAgICAgIHZvaWQgYmVnaW4oKTsKLSAgICAgICAgdm9pZCBlbmQoKTsKKyAgICAgICAgdm9p ZCBlbmQodW5zaWduZWQgcGl4ZWxzVXBsb2FkZWQpOwogICAgICAgICBib29sIGlzUGVuZGluZygp OwogICAgICAgICB2b2lkIHdhaXQoKTsKKyAgICAgICAgdW5zaWduZWQgdmFsdWUoKTsKKyAgICAg ICAgdW5zaWduZWQgcGl4ZWxzVXBsb2FkZWQoKTsKIAogICAgIHByaXZhdGU6CiAgICAgICAgIGV4 cGxpY2l0IFF1ZXJ5KFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0QqKTsKIAogICAgICAgICBX ZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEKiBtX2NvbnRleHQ7CiAgICAgICAgIHVuc2lnbmVk IG1fcXVlcnlJZDsKKyAgICAgICAgdW5zaWduZWQgbV9waXhlbHNVcGxvYWRlZDsKICAgICB9Owog CiAgICAgVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0 M0QqKTsKQEAgLTgxLDYgKzg2LDkgQEAgcHJpdmF0ZToKICAgICBzaXplX3QgbV9tYXhQZW5kaW5n UXVlcmllczsKICAgICBEZXF1ZTxPd25QdHI8UXVlcnk+ID4gbV9wZW5kaW5nUXVlcmllczsKICAg ICBEZXF1ZTxPd25QdHI8UXVlcnk+ID4gbV9hdmFpbGFibGVRdWVyaWVzOworICAgIGRvdWJsZSBt X2F2ZXJhZ2VVcGxvYWRUaW1lOworICAgIHVuc2lnbmVkIG1fYXZlcmFnZVBpeGVsc1BlclNlY29u ZDsKKyAgICB1bnNpZ25lZCBtX3BpeGVsc1VwbG9hZGVkOwogfTsKIAogfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVW50aHJvdHRsZWRUZXh0 dXJlVXBsb2FkZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L1VudGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyLmgKaW5kZXggZmE5Njg5OWI2MTllYzRmNmEyNzMz ODhkZmZkNzY0YjAwMDZlMTE4My4uNjg5MzQwODFmY2YxMWRmYWY1N2U5OGVlMTM5ZjY1MTBmMTQ5 MjlkZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vVW50aHJvdHRsZWRUZXh0dXJlVXBsb2FkZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9VbnRocm90dGxlZFRleHR1cmVVcGxvYWRlci5oCkBAIC00 MCw2ICs0MCw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIH5VbnRocm90dGxlZFRleHR1cmVVcGxv YWRlcigpIHsgfQogCiAgICAgdmlydHVhbCBib29sIGlzQnVzeSgpIE9WRVJSSURFIHsgcmV0dXJu IGZhbHNlOyB9CisgICAgdmlydHVhbCBzaXplX3QgcGVuZGluZ1VwbG9hZEdyb3VwcygpIHsgcmV0 dXJuIDA7IH0KKyAgICB2aXJ0dWFsIGRvdWJsZSBhdmVyYWdlUGl4ZWxzUGVyU2Vjb25kKCkgeyBy ZXR1cm4gMWUxMDA7IH0KICAgICB2aXJ0dWFsIHZvaWQgYmVnaW5VcGxvYWRzKCkgT1ZFUlJJREUg eyB9CiAgICAgdmlydHVhbCB2b2lkIGVuZFVwbG9hZHMoKSBPVkVSUklERSB7IH0KICAgICB2aXJ0 dWFsIHZvaWQgdXBsb2FkVGV4dHVyZShDQ1Jlc291cmNlUHJvdmlkZXIqIHJlc291cmNlUHJvdmlk ZXIsIFBhcmFtZXRlcnMgdXBsb2FkKSBPVkVSUklERSB7IHVwbG9hZC50ZXh0dXJlLT51cGRhdGVS ZWN0KHJlc291cmNlUHJvdmlkZXIsIHVwbG9hZC5zb3VyY2VSZWN0LCB1cGxvYWQuZGVzdE9mZnNl dCk7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL2NjL0NDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlci5jcHAK aW5kZXggNmZjNzcxZTk1OTA1ZWUzYzg3ZTYxYjAxZjY4NjYzYjJmOTA2MDFjNy4uMjUyNTgzZGI1 NGM1YjM5ZmFkODliYjQ2ZmZiYTNmMjhhMzk3ZGFjNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxl ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlci5jcHAKQEAgLTMwLDE1ICszMCwyMCBAQAogI2luY2x1 ZGUgIkdyYXBoaWNzQ29udGV4dDNELmgiCiAjaW5jbHVkZSAiVGV4dHVyZUNvcGllci5oIgogI2lu Y2x1ZGUgIlRleHR1cmVVcGxvYWRlci5oIgorI2luY2x1ZGUgIlRyYWNlRXZlbnQuaCIKICNpbmNs dWRlIDx3dGYvQ3VycmVudFRpbWUuaD4KIAogbmFtZXNwYWNlIHsKIAorc3RhdGljIGNvbnN0IHNp emVfdCBwaXhlbHNQZXJUZXh0dXJlID0gMjU2ICogMjU2OworCiAvLyBOdW1iZXIgb2YgdGV4dHVy ZXMgdG8gdXBkYXRlIHdpdGggZWFjaCBjYWxsIHRvIHVwZGF0ZU1vcmVUZXh0dXJlc0lmRW5vdWdo VGltZVJlbWFpbmluZygpLgotc3RhdGljIGNvbnN0IHNpemVfdCB0ZXh0dXJlVXBkYXRlc1BlclRp Y2sgPSAxMjsKK3N0YXRpYyBjb25zdCBzaXplX3QgdGV4dHVyZVVwZGF0ZXNQZXJUaWNrRGVmYXVs dCA9IDEyOwogCiAvLyBNZWFzdXJlZCBpbiBzZWNvbmRzLgotc3RhdGljIGNvbnN0IGRvdWJsZSB0 ZXh0dXJlVXBkYXRlVGlja1JhdGUgPSAwLjAwNDsKK3N0YXRpYyBjb25zdCBkb3VibGUgdGV4dHVy ZVVwZGF0ZVRpY2tSYXRlTWluID0gMC4wMDE7CitzdGF0aWMgY29uc3QgZG91YmxlIHRleHR1cmVV cGRhdGVUaWNrUmF0ZU1heCA9IDAuMDA4Oworc3RhdGljIGNvbnN0IGRvdWJsZSB0ZXh0dXJlVXBk YXRlVGlja1JhdGVBZGp1c3QgPSAwLjAwMTsKIAogLy8gRmx1c2ggaW50ZXJ2YWwgd2hlbiBwZXJm b3JtaW5nIHRleHR1cmUgdXBsb2Fkcy4KIHN0YXRpYyBjb25zdCBpbnQgdGV4dHVyZVVwbG9hZEZs dXNoUGVyaW9kID0gNDsKQEAgLTQ5LDExICs1NCw3MyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK IHNpemVfdCBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjptYXhQYXJ0aWFsVGV4dHVyZVVwZGF0 ZXMoKQogewotICAgIHJldHVybiB0ZXh0dXJlVXBkYXRlc1BlclRpY2s7CisgICAgcmV0dXJuIHRl eHR1cmVVcGRhdGVzUGVyVGlja0RlZmF1bHQ7Cit9CisKK2RvdWJsZSBDQ1RleHR1cmVVcGRhdGVD b250cm9sbGVyOjphdmVyYWdlUGl4ZWxzUGVyU2Vjb25kKCkKK3sKKyAgICAvLyBUT0RPOiBUaGlz IG9ubHkgdGFrZXMgaW50byBhY2NvdW50IEdQVSBwcm9jZXNzIHRpbWUuCisgICAgLy8gV2Ugc2hv dWxkIGFsc28gY2FsY3VsYXRlIFJlbmRlciBwcmVjZXNzIHRpbWUgYW5kIHRha2UgdGhlIG1pbmlt dW0gb2YgdGhlIHR3by4KKyAgICByZXR1cm4gbV91cGxvYWRlci0+YXZlcmFnZVBpeGVsc1BlclNl Y29uZCgpOworfQorCisvLyBUaGUgZ29hbCBvZiB0aGlzIG1ldGhvZCBpcyB0byBvcHRpbWl6ZSB0 aGUgdmFsdWVzIG9mIG1fdGV4dHVyZVVwZGF0ZVRpY2tQZXJpb2QKKy8vIGFuZCBtX3RleHR1cmVV cGRhdGVzUGVyVGljayBpbiBhbiBhdHRlbXB0IHRvOgorLy8gMSkgQXZvaWQgdGlja2luZyB0b28g b2Z0ZW4KKy8vIDIpIE1pbmltaXplIHRoZSBhbW91bnQgb2YgaWRsZSB0aW1lIHRoYXQgd2UgYXJl bid0IHVwbG9hZGluZy4KK3ZvaWQgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRlVGV4 dHVyZUNvdW50QW5kUmF0ZSgpCit7CisgICAgLy8gSWYgdGhpcyBpcyBvdXIgZmlyc3QgdXBkYXRl IGluIGEgc2VyaWVzLCB3ZSB3b24ndCBoYXZlIGFueSBtZWFuaW5nZnVsbCBmZWVkYmFjay4KKyAg ICBpZiAobV9zZXF1ZW50aWFsVXBkYXRlQ291bnQgPCAxKSB7CisgICAgICAgIG1fdGltZXItPnN0 YXJ0T25lU2hvdCh1cGRhdGVNb3JlVGV4dHVyZXNUaW1lKCkpOworICAgICAgICByZXR1cm47Cisg ICAgfQorCisgICAgZG91YmxlIGVwc2lsb24gPSAxZS02OyAvLyBQcmV2ZW50cyByb3VuZGluZyBk b3duIHRvIHplcm8uCisKKyAgICBkb3VibGUgdGFyZ2V0TGF0ZW5jeSA9IC4wMDI7CisgICAgc2l6 ZV90IHRhcmdldFVwbG9hZEdyb3VwcyA9IHN0ZDo6bWF4KDEsIGludCh0YXJnZXRMYXRlbmN5IC8g bV90ZXh0dXJlVXBkYXRlVGlja1BlcmlvZCArIC41KSk7CisKKyAgICBpZiAobV91cGxvYWRlci0+ cGVuZGluZ1VwbG9hZEdyb3VwcygpIDwgdGFyZ2V0VXBsb2FkR3JvdXBzKSB7CisgICAgICAgIC8v IE91ciB0ZXh0dXJlIHVwbG9hZCBwaXBsaW5lIGhhcyBhIGJ1YmJsZS4gU3BlZWQgaXQgdXAuCisg ICAgICAgIG1fdGV4dHVyZVVwZGF0ZVRpY2tQZXJpb2QgLT0gdGV4dHVyZVVwZGF0ZVRpY2tSYXRl QWRqdXN0OworICAgICAgICBpZiAobV90ZXh0dXJlVXBkYXRlVGlja1BlcmlvZCA8IHRleHR1cmVV cGRhdGVUaWNrUmF0ZU1pbikKKyAgICAgICAgICAgIG1fdGV4dHVyZVVwZGF0ZVRpY2tQZXJpb2Qg PSB0ZXh0dXJlVXBkYXRlVGlja1JhdGVNaW47CisKKyAgICAgICAgZG91YmxlIHRleHR1cmVzUGVy U2Vjb25kID0gYXZlcmFnZVBpeGVsc1BlclNlY29uZCgpIC8gcGl4ZWxzUGVyVGV4dHVyZTsKKyAg ICAgICAgbV90ZXh0dXJlVXBkYXRlc1BlclRpY2sgPSBjZWlsKHRleHR1cmVzUGVyU2Vjb25kICog bV90ZXh0dXJlVXBkYXRlVGlja1BlcmlvZCAqIDEuNSArIGVwc2lsb24pOworCisgICAgICAgIG1f dGltZXItPnN0YXJ0T25lU2hvdCh1cGRhdGVNb3JlVGV4dHVyZXNUaW1lKCkpOworICAgIH0gZWxz ZSBpZiAobV91cGxvYWRlci0+cGVuZGluZ1VwbG9hZEdyb3VwcygpID09IHRhcmdldFVwbG9hZEdy b3VwcykgeworICAgICAgICAvLyBXZSBhcmUgaW4gYSBnb29kIHN0YXRlLCBidXQgZXJyIG9uIHRo ZSBzaWRlIG9mIHNwZWVkaW5nIHVwLgorICAgICAgICBtX3RleHR1cmVVcGRhdGVUaWNrUGVyaW9k IC09IHRleHR1cmVVcGRhdGVUaWNrUmF0ZUFkanVzdCAvIDQ7CisgICAgICAgIGlmIChtX3RleHR1 cmVVcGRhdGVUaWNrUGVyaW9kIDwgdGV4dHVyZVVwZGF0ZVRpY2tSYXRlTWluKQorICAgICAgICAg ICAgbV90ZXh0dXJlVXBkYXRlVGlja1BlcmlvZCA9IHRleHR1cmVVcGRhdGVUaWNrUmF0ZU1pbjsK KworICAgICAgICBkb3VibGUgdGV4dHVyZXNQZXJTZWNvbmQgPSBhdmVyYWdlUGl4ZWxzUGVyU2Vj b25kKCkgLyBwaXhlbHNQZXJUZXh0dXJlOworICAgICAgICBtX3RleHR1cmVVcGRhdGVzUGVyVGlj ayA9IGNlaWwodGV4dHVyZXNQZXJTZWNvbmQgKiBtX3RleHR1cmVVcGRhdGVUaWNrUGVyaW9kICog MS4yICsgZXBzaWxvbik7CisKKyAgICAgICAgbV90aW1lci0+c3RhcnRPbmVTaG90KHVwZGF0ZU1v cmVUZXh0dXJlc1RpbWUoKSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gV2UgYXJlIHVwbG9h ZGluZyB0b28gZmFzdC4gU2xvdyBkb3duLgorICAgICAgICBtX3RleHR1cmVVcGRhdGVUaWNrUGVy aW9kICs9IHRleHR1cmVVcGRhdGVUaWNrUmF0ZUFkanVzdDsKKyAgICAgICAgaWYgKG1fdGV4dHVy ZVVwZGF0ZVRpY2tQZXJpb2QgPiB0ZXh0dXJlVXBkYXRlVGlja1JhdGVNYXgpCisgICAgICAgICAg ICBtX3RleHR1cmVVcGRhdGVUaWNrUGVyaW9kID0gdGV4dHVyZVVwZGF0ZVRpY2tSYXRlTWF4Owor CisgICAgICAgIGRvdWJsZSB0ZXh0dXJlc1BlclNlY29uZCA9IGF2ZXJhZ2VQaXhlbHNQZXJTZWNv bmQoKSAvIHBpeGVsc1BlclRleHR1cmU7CisgICAgICAgIG1fdGV4dHVyZVVwZGF0ZXNQZXJUaWNr ID0gY2VpbCh0ZXh0dXJlc1BlclNlY29uZCAqIG1fdGV4dHVyZVVwZGF0ZVRpY2tQZXJpb2QgKiAu MjUgKyBlcHNpbG9uKTsKKworICAgICAgICAvLyBFdmVuIHRob3VnaCB3ZSBhcmUgc2xvd2luZyBk b3duIG92ZWFyYWxsLCB3ZSBhcmUgZ29pbmcgdG8gbWFrZSB0aGUgbmV4dAorICAgICAgICAvLyB0 aWNrIGZhc3QgYmVjYXVzZSB3ZSB3aWxsIG5vdCBiZSBkb2luZyBhbnl0aGluZyB0aGlzIHRpY2sg YW5kIGRvbid0IHdhbnQKKyAgICAgICAgLy8gdG8gY29tZSBiYWNrIHRvbyBsYXRlLgorICAgICAg ICBtX3RpbWVyLT5zdGFydE9uZVNob3QodXBkYXRlTW9yZVRleHR1cmVzVGltZSgpICogMyAvIDQp OworICAgIH0KIH0KIAogdm9pZCBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjp1cGRhdGVUZXh0 dXJlcyhDQ1Jlc291cmNlUHJvdmlkZXIqIHJlc291cmNlUHJvdmlkZXIsIFRleHR1cmVDb3BpZXIq IGNvcGllciwgVGV4dHVyZVVwbG9hZGVyKiB1cGxvYWRlciwgQ0NUZXh0dXJlVXBkYXRlUXVldWUq IHF1ZXVlLCBzaXplX3QgY291bnQpCiB7CisgICAgVFJBQ0VfRVZFTlQyKCJjYyIsICJDQ1RleHR1 cmVVcGRhdGVDb250cm9sbGVyOjp1cGRhdGVUZXh0dXJlcyIsICJmdWxsIiwgaW50KHF1ZXVlLT5m dWxsVXBsb2FkU2l6ZSgpKSwgInBhcnRpYWwiLCBpbnQocXVldWUtPnBhcnRpYWxVcGxvYWRTaXpl KCkpKTsKKwogICAgIGlmIChxdWV1ZS0+ZnVsbFVwbG9hZFNpemUoKSB8fCBxdWV1ZS0+cGFydGlh bFVwbG9hZFNpemUoKSkgewogICAgICAgICBpZiAodXBsb2FkZXItPmlzQnVzeSgpKQogICAgICAg ICAgICAgcmV0dXJuOwpAQCAtNzQsMTQgKzE0MSwxNCBAQCB2b2lkIENDVGV4dHVyZVVwZGF0ZUNv bnRyb2xsZXI6OnVwZGF0ZVRleHR1cmVzKENDUmVzb3VyY2VQcm92aWRlciogcmVzb3VyY2VQcm92 aQogCiAgICAgICAgIGJvb2wgbW9yZVVwbG9hZHMgPSBxdWV1ZS0+ZnVsbFVwbG9hZFNpemUoKTsK IAotICAgICAgICBBU1NFUlQocXVldWUtPnBhcnRpYWxVcGxvYWRTaXplKCkgPD0gY291bnQpOwog ICAgICAgICAvLyBXZSBuZWVkIGFub3RoZXIgdXBkYXRlIGJhdGNoIGlmIHRoZSBudW1iZXIgb2Yg dXBkYXRlcyByZW1haW5pbmcKICAgICAgICAgLy8gaW4gfGNvdW50fCBpcyBncmVhdGVyIHRoYW4g dGhlIHJlbWFpbmluZyBwYXJ0aWFsIGVudHJpZXMuCi0gICAgICAgIGlmICgoY291bnQgLSBmdWxs VXBsb2FkQ291bnQpIDwgcXVldWUtPnBhcnRpYWxVcGxvYWRTaXplKCkpCisgICAgICAgIGlmIChm dWxsVXBsb2FkQ291bnQgJiYgKGNvdW50IC0gZnVsbFVwbG9hZENvdW50KSA8IHF1ZXVlLT5wYXJ0 aWFsVXBsb2FkU2l6ZSgpKQogICAgICAgICAgICAgbW9yZVVwbG9hZHMgPSB0cnVlOwogCiAgICAg ICAgIGlmIChtb3JlVXBsb2FkcykgewogICAgICAgICAgICAgdXBsb2FkZXItPmVuZFVwbG9hZHMo KTsKKyAgICAgICAgICAgIHJlc291cmNlUHJvdmlkZXItPnNoYWxsb3dGbHVzaElmU3VwcG9ydGVk KCk7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KIApAQCAtOTgsNiArMTY1LDcgQEAg dm9pZCBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjp1cGRhdGVUZXh0dXJlcyhDQ1Jlc291cmNl UHJvdmlkZXIqIHJlc291cmNlUHJvdmkKICAgICAgICAgICAgIHJlc291cmNlUHJvdmlkZXItPnNo YWxsb3dGbHVzaElmU3VwcG9ydGVkKCk7CiAKICAgICAgICAgdXBsb2FkZXItPmVuZFVwbG9hZHMo KTsKKyAgICAgICAgcmVzb3VyY2VQcm92aWRlci0+c2hhbGxvd0ZsdXNoSWZTdXBwb3J0ZWQoKTsK ICAgICB9CiAKICAgICBzaXplX3QgY29weUNvdW50ID0gMDsKQEAgLTEyMCw3ICsxODgsMTMgQEAg Q0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6Q0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcihDQ1Ro cmVhZCogdGhyZWFkLCBQYXNzT3duUHQKICAgICAsIG1fY29waWVyKGNvcGllcikKICAgICAsIG1f dXBsb2FkZXIodXBsb2FkZXIpCiAgICAgLCBtX21vbm90b25pY1RpbWVMaW1pdCgwKQorICAgICwg bV90ZXh0dXJlVXBkYXRlVGlja1BlcmlvZCh0ZXh0dXJlVXBkYXRlVGlja1JhdGVNaW4pCisgICAg LCBtX3RleHR1cmVVcGRhdGVzUGVyVGljayh0ZXh0dXJlVXBkYXRlc1BlclRpY2tEZWZhdWx0KQog ICAgICwgbV9maXJzdFVwZGF0ZUF0dGVtcHQodHJ1ZSkKKyAgICAsIG1fZW5vdWdoVGltZUxhc3RV cGRhdGUodHJ1ZSkKKyAgICAsIG1fYnVzeUNvdW50KDApCisgICAgLCBtX25vdEJ1c3lDb3VudCgw KQorICAgICwgbV9zZXF1ZW50aWFsVXBkYXRlQ291bnQoMCkKIHsKIH0KIApAQCAtMTM1LDEwICsy MDksMTcgQEAgYm9vbCBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjpoYXNNb3JlVXBkYXRlcygp IGNvbnN0CiAKIHZvaWQgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRlTW9yZVRleHR1 cmVzKGRvdWJsZSBtb25vdG9uaWNUaW1lTGltaXQpCiB7CisgICAgVFJBQ0VfRVZFTlQyKCJjYyIs ICJDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjp1cGRhdGVNb3JlVGV4dHVyZXMiLCAiVXBkYXRl c1BlclRpY2siLCAoaW50KW1fdGV4dHVyZVVwZGF0ZXNQZXJUaWNrLCAiVGlja1BlcmlvZCIsIG1f dGV4dHVyZVVwZGF0ZVRpY2tQZXJpb2QpCisKICAgICBtX21vbm90b25pY1RpbWVMaW1pdCA9IG1v bm90b25pY1RpbWVMaW1pdDsKIAotICAgIGlmICghbV9xdWV1ZS0+aGFzTW9yZVVwZGF0ZXMoKSkK KyAgICBpZiAobV9lbm91Z2hUaW1lTGFzdFVwZGF0ZSkKKyAgICAgICAgbV9zZXF1ZW50aWFsVXBk YXRlQ291bnQgPSAwOworCisgICAgaWYgKCFtX3F1ZXVlLT5oYXNNb3JlVXBkYXRlcygpKSB7Cisg ICAgICAgIG1fZW5vdWdoVGltZUxhc3RVcGRhdGUgPSB0cnVlOwogICAgICAgICByZXR1cm47Cisg ICAgfQogCiAgICAgLy8gQ2FsbCB1cGRhdGVNb3JlVGV4dHVyZXNOb3coKSBkaXJlY3RseSB1bmxl c3MgaXQncyB0aGUgZmlyc3QgdXBkYXRlCiAgICAgLy8gYXR0ZW1wdC4gVGhpcyBlbnN1cmVzIHRo YXQgd2UgZW1wdHkgdGhlIHVwZGF0ZSBxdWV1ZSBpbiBhIGZpbml0ZQpAQCAtMTUyLDYgKzIzMywx MCBAQCB2b2lkIENDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OnVwZGF0ZU1vcmVUZXh0dXJlcyhk b3VibGUgbW9ub3RvbmljVGltZUxpbWl0KQogCiB2b2lkIENDVGV4dHVyZVVwZGF0ZUNvbnRyb2xs ZXI6Om9uVGltZXJGaXJlZCgpCiB7CisgICAgVFJBQ0VfRVZFTlQyKCJjYyIsICJDQ1RleHR1cmVV cGRhdGVDb250cm9sbGVyOjpvblRpbWVyRmlyZWQiLCAiVXBkYXRlc1BlclRpY2siLCAoaW50KW1f dGV4dHVyZVVwZGF0ZXNQZXJUaWNrLCAiVGlja1BlcmlvZCIsIG1fdGV4dHVyZVVwZGF0ZVRpY2tQ ZXJpb2QpCisKKyAgICBtX3NlcXVlbnRpYWxVcGRhdGVDb3VudCsrOworCiAgICAgaWYgKCFtX3F1 ZXVlLT5oYXNNb3JlVXBkYXRlcygpKQogICAgICAgICByZXR1cm47CiAKQEAgLTE2NSwyNCArMjUw LDI1IEBAIGRvdWJsZSBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjptb25vdG9uaWNUaW1lTm93 KCkgY29uc3QKIAogZG91YmxlIENDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OnVwZGF0ZU1vcmVU ZXh0dXJlc1RpbWUoKSBjb25zdAogewotICAgIHJldHVybiB0ZXh0dXJlVXBkYXRlVGlja1JhdGU7 CisgICAgcmV0dXJuIG1fdGV4dHVyZVVwZGF0ZVRpY2tQZXJpb2Q7CiB9CiAKIHNpemVfdCBDQ1Rl eHR1cmVVcGRhdGVDb250cm9sbGVyOjp1cGRhdGVNb3JlVGV4dHVyZXNTaXplKCkgY29uc3QKIHsK LSAgICByZXR1cm4gdGV4dHVyZVVwZGF0ZXNQZXJUaWNrOworICAgIHJldHVybiBtX3RleHR1cmVV cGRhdGVzUGVyVGljazsKIH0KIAogdm9pZCBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjp1cGRh dGVNb3JlVGV4dHVyZXNJZkVub3VnaFRpbWVSZW1haW5pbmcoKQogewotICAgIGJvb2wgaGFzVGlt ZVJlbWFpbmluZyA9IG1vbm90b25pY1RpbWVOb3coKSA8IG1fbW9ub3RvbmljVGltZUxpbWl0IC0g dXBkYXRlTW9yZVRleHR1cmVzVGltZSgpOwotICAgIGlmIChoYXNUaW1lUmVtYWluaW5nKQorICAg IG1fZW5vdWdoVGltZUxhc3RVcGRhdGUgPSBtb25vdG9uaWNUaW1lTm93KCkgPCBtX21vbm90b25p Y1RpbWVMaW1pdCAtIHVwZGF0ZU1vcmVUZXh0dXJlc1RpbWUoKTsKKyAgICBpZiAobV9lbm91Z2hU aW1lTGFzdFVwZGF0ZSkKICAgICAgICAgdXBkYXRlTW9yZVRleHR1cmVzTm93KCk7CiB9CiAKIHZv aWQgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRlTW9yZVRleHR1cmVzTm93KCkKIHsK LSAgICBtX3RpbWVyLT5zdGFydE9uZVNob3QodXBkYXRlTW9yZVRleHR1cmVzVGltZSgpKTsKKyAg ICB1cGRhdGVUZXh0dXJlQ291bnRBbmRSYXRlKCk7CisgICAgVFJBQ0VfRVZFTlQyKCJjYyIsICJD Q1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjp1cGRhdGVNb3JlVGV4dHVyZXNOb3ciLCAiVXBkYXRl c1BlclRpY2siLCAoaW50KW1fdGV4dHVyZVVwZGF0ZXNQZXJUaWNrLCAiVGlja1BlcmlvZCIsIG1f dGV4dHVyZVVwZGF0ZVRpY2tQZXJpb2QpOwogICAgIHVwZGF0ZVRleHR1cmVzKG1fcmVzb3VyY2VQ cm92aWRlciwgbV9jb3BpZXIsIG1fdXBsb2FkZXIsIG1fcXVldWUuZ2V0KCksIHVwZGF0ZU1vcmVU ZXh0dXJlc1NpemUoKSk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXIuaCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGV4dHVyZVVwZGF0ZUNv bnRyb2xsZXIuaAppbmRleCBkZDc1OGJlYjRkOWZjZDg2NmUxOGM4NDdjY2QwYWYyODliYTk1YmQx Li5lNDRkZDdmODE5N2FiODZkMzQzMjlhMGFjNGZiOTI2OGZhYWRmNmVmIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RleHR1cmVVcGRh dGVDb250cm9sbGVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vY2MvQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlci5oCkBAIC02Miw2ICs2MiwxMCBAQCBw dWJsaWM6CiBwcm90ZWN0ZWQ6CiAgICAgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcihDQ1RocmVh ZCosIFBhc3NPd25QdHI8Q0NUZXh0dXJlVXBkYXRlUXVldWU+LCBDQ1Jlc291cmNlUHJvdmlkZXIq LCBUZXh0dXJlQ29waWVyKiwgVGV4dHVyZVVwbG9hZGVyKik7CiAKKworICAgIGRvdWJsZSBhdmVy YWdlUGl4ZWxzUGVyU2Vjb25kKCk7CisgICAgdm9pZCB1cGRhdGVUZXh0dXJlQ291bnRBbmRSYXRl KCk7CisKICAgICB2b2lkIHVwZGF0ZU1vcmVUZXh0dXJlc0lmRW5vdWdoVGltZVJlbWFpbmluZygp OwogICAgIHZvaWQgdXBkYXRlTW9yZVRleHR1cmVzTm93KCk7CiAKQEAgLTcyLDcgKzc2LDEzIEBA IHByb3RlY3RlZDoKICAgICBUZXh0dXJlQ29waWVyKiBtX2NvcGllcjsKICAgICBUZXh0dXJlVXBs b2FkZXIqIG1fdXBsb2FkZXI7CiAgICAgZG91YmxlIG1fbW9ub3RvbmljVGltZUxpbWl0OworICAg IGRvdWJsZSBtX3RleHR1cmVVcGRhdGVUaWNrUGVyaW9kOworICAgIHNpemVfdCBtX3RleHR1cmVV cGRhdGVzUGVyVGljazsKICAgICBib29sIG1fZmlyc3RVcGRhdGVBdHRlbXB0OworICAgIGJvb2wg bV9lbm91Z2hUaW1lTGFzdFVwZGF0ZTsKKyAgICBzaXplX3QgbV9idXN5Q291bnQ7CisgICAgc2l6 ZV90IG1fbm90QnVzeUNvdW50OworICAgIHNpemVfdCBtX3NlcXVlbnRpYWxVcGRhdGVDb3VudDsK IH07CiAKIH0K 163494 2012-09-11 18:44:23 -0700 2013-03-12 20:45:55 -0700 Patch bug-96067-20120911184357.patch text/plain 31715 brianderson U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3Njk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWY2NGExNWYwODM4NWFk YjM5OGE5OGZmMDBjNTJjYTFjZmZkN2EzNS4uYWY0OThmMDFlOGUyMWY1OGU2MzQ1MmM4YmY0YjIw M2Q1ZmU3Mzc5MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU5IEBACisyMDEyLTA5LTA2ICBCcmlh biBBbmRlcnNvbiAgPGJyaWFuZGVyc29uQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21p dW1dIEFkYXB0aXZlbHkgdGhyb3R0bGUgdGV4dHVyZSB1cGxvYWRzCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05NjA2NworCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdlIG5lZWQgYWRhcHRpdmUgdGV4dHVyZSB1 cGxvYWRpbmcgYmVjYXVzZSB3ZSBydW4gb24gYSB3aWRlIHZhcmlldHkKKyAgICAgICAgb2Ygc3lz dGVtcyBhbmQgYSBvbmUgc2l6ZSBmaXRzIGFsbCBwb2xpY3kgd2lsbCBub3Qgd29yay4KKyAgICAg ICAgVGhpcyBwYXRjaCBtYWludGFpbnMgYSB0aWNrIHJhdGUgb2YgNG1zIGFuZCBkZWZhdWx0IHVw bG9hZCBjb3VudCBvZgorICAgICAgICAxMiB0ZXh0dXJlcyBwZXIgdGljaywgYnV0IGFsbG93cyBm b3IgbW9yZSB0ZXh0dXJlcyBwZXIgdGljayBpZiB3ZSd2ZQorICAgICAgICBtZWFzdXJlZCB0aGF0 IHdlIGNhbiBiZSBmYXN0ZXIuCisgICAgICAgIFRoZSBudW1iZXIgb2YgcGFydGlhbCB1cGRhdGVz IGFsbG93ZWQgaXMgYWxzbyBjb21tdW5pY2F0ZWQgZnJvbSB0aGUKKyAgICAgICAgaW1wbCB0aHJl YWQgdG8gdGhlIG1haW4gdGhyZWFkIHBlcmlvZGljYWxseS4gCisKKyAgICAgICAgTm8gbmV3IHRl c3RzIChPT1BTISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UZXh0 dXJlVXBsb2FkZXIuaDoKKyAgICAgICAgKFRleHR1cmVVcGxvYWRlcik6CisgICAgICAgICogcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6UXVlcnk6OlF1ZXJ5KToK KyAgICAgICAgKFdlYkNvcmU6OlRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6UXVlcnk6OmVuZCk6 CisgICAgICAgIChXZWJDb3JlOjpUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OlF1ZXJ5Ojp3YWl0 KToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6VGhyb3R0bGVkVGV4dHVy ZVVwbG9hZGVyOjpRdWVyeTo6dmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6VGhyb3R0bGVkVGV4 dHVyZVVwbG9hZGVyOjpRdWVyeTo6cGl4ZWxzVXBsb2FkZWQpOgorICAgICAgICAoV2ViQ29yZTo6 VGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjpUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXIpOgorICAg ICAgICAoV2ViQ29yZTo6VGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjppc0J1c3kpOgorICAgICAg ICAoV2ViQ29yZTo6VGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjpwZW5kaW5nVXBsb2FkR3JvdXBz KToKKyAgICAgICAgKFdlYkNvcmU6OlRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6YXZlcmFnZVBp eGVsc1BlclNlY29uZCk6CisgICAgICAgIChXZWJDb3JlOjpUaHJvdHRsZWRUZXh0dXJlVXBsb2Fk ZXI6OmJlZ2luVXBsb2Fkcyk6CisgICAgICAgIChXZWJDb3JlOjpUaHJvdHRsZWRUZXh0dXJlVXBs b2FkZXI6OmVuZFVwbG9hZHMpOgorICAgICAgICAoV2ViQ29yZTo6VGhyb3R0bGVkVGV4dHVyZVVw bG9hZGVyOjp1cGxvYWRUZXh0dXJlKToKKyAgICAgICAgKFdlYkNvcmU6OlRocm90dGxlZFRleHR1 cmVVcGxvYWRlcjo6cHJvY2Vzc1F1ZXJpZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL1Rocm90dGxlZFRleHR1cmVVcGxvYWRlci5oOgorICAgICAgICAoVGhyb3R0bGVk VGV4dHVyZVVwbG9hZGVyKToKKyAgICAgICAgKFF1ZXJ5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9VbnRocm90dGxlZFRleHR1cmVVcGxvYWRlci5oOgorICAgICAgICAo V2ViQ29yZTo6VW50aHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OnBlbmRpbmdVcGxvYWRHcm91cHMp OgorICAgICAgICAoV2ViQ29yZTo6VW50aHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OmF2ZXJhZ2VQ aXhlbHNQZXJTZWNvbmQpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2Nj L0NDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q0NUZXh0 dXJlVXBkYXRlQ29udHJvbGxlcjo6bWF4UGFydGlhbFRleHR1cmVVcGRhdGVzKToKKyAgICAgICAg KFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6Q0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6 YXZlcmFnZVBpeGVsc1BlclNlY29uZCk6CisgICAgICAgIChXZWJDb3JlOjpDQ1RleHR1cmVVcGRh dGVDb250cm9sbGVyOjp1cGRhdGVUZXh0dXJlQ291bnRBbmRSYXRlKToKKyAgICAgICAgKFdlYkNv cmU6OkNDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OnVwZGF0ZVRleHR1cmVzKToKKyAgICAgICAg KFdlYkNvcmU6OkNDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OkNDVGV4dHVyZVVwZGF0ZUNvbnRy b2xsZXIpOgorICAgICAgICAoV2ViQ29yZTo6Q0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBk YXRlTW9yZVRleHR1cmVzKToKKyAgICAgICAgKFdlYkNvcmU6OkNDVGV4dHVyZVVwZGF0ZUNvbnRy b2xsZXI6Om9uVGltZXJGaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpDQ1RleHR1cmVVcGRhdGVD b250cm9sbGVyOjp1cGRhdGVNb3JlVGV4dHVyZXNUaW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkND VGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OnVwZGF0ZU1vcmVUZXh0dXJlc1NpemUpOgorICAgICAg ICAoV2ViQ29yZTo6Q0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRlTW9yZVRleHR1cmVz SWZFbm91Z2hUaW1lUmVtYWluaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkNDVGV4dHVyZVVwZGF0 ZUNvbnRyb2xsZXI6OnVwZGF0ZU1vcmVUZXh0dXJlc05vdyk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlci5oOgorICAgICAg ICAoQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcik6CisKIDIwMTItMDktMDUgIFRpbSBIb3J0b24g IDx0aW1vdGh5X2hvcnRvbkBhcHBsZS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZDsgcmV2ZXJ0 IGEgY2hhbmdlIHRvIFNjcm9sbGluZ1RyZWVOb2RlTWFjIHdoaWNoIGFjY2lkZW50YWxseQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVy ZVVwbG9hZGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U ZXh0dXJlVXBsb2FkZXIuaAppbmRleCAwYTg2MTYxMmUzNTlhZmQ2ZTQyZDkwNjExZTU2N2U0YzM2 MjJlNjc2Li4wOTIwMDNjZTA5NDYxZTc2N2NhZjFiOTVkYzk1Yzk3NWEyYjk0ZDIwIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UZXh0dXJlVXBs b2FkZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U ZXh0dXJlVXBsb2FkZXIuaApAQCAtNDAsNiArNDAsOSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB+ VGV4dHVyZVVwbG9hZGVyKCkgeyB9CiAKICAgICB2aXJ0dWFsIGJvb2wgaXNCdXN5KCkgPSAwOwor CisgICAgLy8gUmV0dXJucyBvdXIgdGhyb3VnaHB1dCBvbiB0aGUgR1BVIHByb2Nlc3MKKyAgICB2 aXJ0dWFsIGRvdWJsZSBlc3RpbWF0ZWRQaXhlbHNQZXJTZWNvbmQoKSA9IDA7CiAgICAgdmlydHVh bCB2b2lkIGJlZ2luVXBsb2FkcygpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgZW5kVXBsb2Fkcygp ID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgdXBsb2FkVGV4dHVyZShDQ1Jlc291cmNlUHJvdmlkZXIq LCBQYXJhbWV0ZXJzKSA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9UaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXIuY3BwIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVy LmNwcAppbmRleCBiODJlZDJiOTdjNjU5MDYzMjVmZWQ4M2IzOTEwOGQ5MzNiYmQyOTk0Li5hNWMx ZDUxNjUyZjhjZTI4MzQ4Y2U0M2UyMjcyNjdhZTJhZTllMzljIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaHJvdHRsZWRUZXh0dXJlVXBsb2Fk ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1Ro cm90dGxlZFRleHR1cmVVcGxvYWRlci5jcHAKQEAgLTIzLDEwICsyMywxMCBAQAogICovCiAKICNp bmNsdWRlICJjb25maWcuaCIKLQogI2luY2x1ZGUgIlRocm90dGxlZFRleHR1cmVVcGxvYWRlci5o IgogCiAjaW5jbHVkZSAiRXh0ZW5zaW9uczNEQ2hyb21pdW0uaCIKKyNpbmNsdWRlIDxhbGdvcml0 aG0+CiAjaW5jbHVkZSA8cHVibGljL1dlYkdyYXBoaWNzQ29udGV4dDNELmg+CiAKIG5hbWVzcGFj ZSB7CkBAIC0zNCw2ICszNCwxMiBAQCBuYW1lc3BhY2UgewogLy8gTnVtYmVyIG9mIHBlbmRpbmcg dGV4dHVyZSB1cGRhdGUgcXVlcmllcyB0byBhbGxvdy4KIHN0YXRpYyBjb25zdCBzaXplX3QgbWF4 UGVuZGluZ1F1ZXJpZXMgPSAyOwogCisvLyBIb3cgbWFueSBwcmV2aW91cyB1cGxvYWRzIHRvIHVz ZSB3aGVuIHByZWRpY3RpbmcgZnV0dXJlIHRocm91Z2hwdXQuCitzdGF0aWMgY29uc3Qgc2l6ZV90 IHVwbG9hZEhpc3RvcnlTaXplID0gMTA7CisKKy8vIERlZmF1bHQgbnVtYmVyIG9mIHBpeGVscyBw ZXIgc2Vjb25kLgorc3RhdGljIGRvdWJsZSBlc3RpbWF0ZWRQaXhlbHNQZXJTZWNvbmREZWZhdWx0 ID0gMjU2ICogMjU2ICogNDg7CisKIH0gLy8gYW5vbnltb3VzIG5hbWVzcGFjZQogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CkBAIC00MSw2ICs0Nyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIFRocm90 dGxlZFRleHR1cmVVcGxvYWRlcjo6UXVlcnk6OlF1ZXJ5KFdlYktpdDo6V2ViR3JhcGhpY3NDb250 ZXh0M0QqIGNvbnRleHQpCiAgICAgOiBtX2NvbnRleHQoY29udGV4dCkKICAgICAsIG1fcXVlcnlJ ZCgwKQorICAgICwgbV9waXhlbHNVcGxvYWRlZCgwKQogewogICAgIG1fcXVlcnlJZCA9IG1fY29u dGV4dC0+Y3JlYXRlUXVlcnlFWFQoKTsKIH0KQEAgLTU1LDkgKzYyLDEwIEBAIHZvaWQgVGhyb3R0 bGVkVGV4dHVyZVVwbG9hZGVyOjpRdWVyeTo6YmVnaW4oKQogICAgIG1fY29udGV4dC0+YmVnaW5R dWVyeUVYVChFeHRlbnNpb25zM0RDaHJvbWl1bTo6Q09NTUFORFNfSVNTVUVEX0NIUk9NSVVNLCBt X3F1ZXJ5SWQpOwogfQogCi12b2lkIFRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6UXVlcnk6OmVu ZCgpCit2b2lkIFRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6UXVlcnk6OmVuZChkb3VibGUgcGl4 ZWxzVXBsb2FkZWQpCiB7CiAgICAgbV9jb250ZXh0LT5lbmRRdWVyeUVYVChFeHRlbnNpb25zM0RD aHJvbWl1bTo6Q09NTUFORFNfSVNTVUVEX0NIUk9NSVVNKTsKKyAgICBtX3BpeGVsc1VwbG9hZGVk ID0gcGl4ZWxzVXBsb2FkZWQ7CiB9CiAKIGJvb2wgVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjpR dWVyeTo6aXNQZW5kaW5nKCkKQEAgLTY5LDE5ICs3NywzMyBAQCBib29sIFRocm90dGxlZFRleHR1 cmVVcGxvYWRlcjo6UXVlcnk6OmlzUGVuZGluZygpCiAKIHZvaWQgVGhyb3R0bGVkVGV4dHVyZVVw bG9hZGVyOjpRdWVyeTo6d2FpdCgpCiB7CisgICAgdmFsdWUoKTsKKyAgICByZXR1cm47Cit9CisK K3Vuc2lnbmVkIFRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6UXVlcnk6OnZhbHVlKCkKK3sKICAg ICB1bnNpZ25lZCByZXN1bHQ7CiAgICAgbV9jb250ZXh0LT5nZXRRdWVyeU9iamVjdHVpdkVYVCht X3F1ZXJ5SWQsIEV4dGVuc2lvbnMzRENocm9taXVtOjpRVUVSWV9SRVNVTFRfRVhULCAmcmVzdWx0 KTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCitkb3VibGUgVGhyb3R0bGVkVGV4dHVyZVVwbG9h ZGVyOjpRdWVyeTo6cGl4ZWxzVXBsb2FkZWQoKQoreworICAgIHJldHVybiBtX3BpeGVsc1VwbG9h ZGVkOwogfQogCiBUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OlRocm90dGxlZFRleHR1cmVVcGxv YWRlcihXZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0KQogICAgIDogbV9jb250 ZXh0KGNvbnRleHQpCiAgICAgLCBtX21heFBlbmRpbmdRdWVyaWVzKG1heFBlbmRpbmdRdWVyaWVz KQorICAgICwgbV9waXhlbHNVcGxvYWRlZCgwKQogewogfQogCiBUaHJvdHRsZWRUZXh0dXJlVXBs b2FkZXI6OlRocm90dGxlZFRleHR1cmVVcGxvYWRlcihXZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4 dDNEKiBjb250ZXh0LCBzaXplX3QgcGVuZGluZ1VwbG9hZExpbWl0KQogICAgIDogbV9jb250ZXh0 KGNvbnRleHQpCiAgICAgLCBtX21heFBlbmRpbmdRdWVyaWVzKHBlbmRpbmdVcGxvYWRMaW1pdCkK KyAgICAsIG1fcGl4ZWxzVXBsb2FkZWQoMCkKIHsKICAgICBBU1NFUlQobV9jb250ZXh0KTsKIH0K QEAgLTg5LDcgKzExMSw2IEBAIFRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6VGhyb3R0bGVkVGV4 dHVyZVVwbG9hZGVyKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0QqCiBUaHJvdHRsZWRUZXh0 dXJlVXBsb2FkZXI6On5UaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXIoKQogewogfQotCiBib29sIFRo cm90dGxlZFRleHR1cmVVcGxvYWRlcjo6aXNCdXN5KCkKIHsKICAgICBwcm9jZXNzUXVlcmllcygp OwpAQCAtMTA0LDggKzEyNSwyMSBAQCBib29sIFRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6aXNC dXN5KCkKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKK2RvdWJsZSBUaHJvdHRsZWRUZXh0dXJlVXBs b2FkZXI6OmVzdGltYXRlZFBpeGVsc1BlclNlY29uZCgpCit7CisgICAgaWYgKG1fcGl4ZWxzUGVy U2Vjb25kSGlzdG9yeS5lbXB0eSgpKQorICAgICAgICByZXR1cm4gZXN0aW1hdGVkUGl4ZWxzUGVy U2Vjb25kRGVmYXVsdDsKKworICAgIC8vIFNvcnQgdGhlIGhpc3RvcnkgYW5kIHVzZSB0aGUgbWVk aWFuIGFzIG91ciBlc3RpbWF0ZS4KKyAgICBzdGQ6OmRlcXVlPGRvdWJsZT4gc29ydGVkSGlzdG9y eShtX3BpeGVsc1BlclNlY29uZEhpc3RvcnkpOworICAgIHN0ZDo6c29ydChzb3J0ZWRIaXN0b3J5 LmJlZ2luKCksIHNvcnRlZEhpc3RvcnkuZW5kKCkpOworICAgIHJldHVybiBzb3J0ZWRIaXN0b3J5 W3NvcnRlZEhpc3Rvcnkuc2l6ZSgpIC8gMl07Cit9CisKIHZvaWQgVGhyb3R0bGVkVGV4dHVyZVVw bG9hZGVyOjpiZWdpblVwbG9hZHMoKQogeworICAgIG1fcGl4ZWxzVXBsb2FkZWQgPSAwOworCiAg ICAgLy8gV2FpdCBmb3IgcXVlcnkgdG8gYmVjb21lIGF2YWlsYWJsZS4KICAgICB3aGlsZSAoaXNC dXN5KCkpCiAgICAgICAgIG1fcGVuZGluZ1F1ZXJpZXMuZmlyc3QoKS0+d2FpdCgpOwpAQCAtMTE2 LDEyICsxNTAsMTMgQEAgdm9pZCBUaHJvdHRsZWRUZXh0dXJlVXBsb2FkZXI6OmJlZ2luVXBsb2Fk cygpCiAKIHZvaWQgVGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyOjplbmRVcGxvYWRzKCkKIHsKLSAg ICBtX2F2YWlsYWJsZVF1ZXJpZXMuZmlyc3QoKS0+ZW5kKCk7CisgICAgbV9hdmFpbGFibGVRdWVy aWVzLmZpcnN0KCktPmVuZChtX3BpeGVsc1VwbG9hZGVkKTsKICAgICBtX3BlbmRpbmdRdWVyaWVz LmFwcGVuZChtX2F2YWlsYWJsZVF1ZXJpZXMudGFrZUZpcnN0KCkpOwogfQogCiB2b2lkIFRocm90 dGxlZFRleHR1cmVVcGxvYWRlcjo6dXBsb2FkVGV4dHVyZShDQ1Jlc291cmNlUHJvdmlkZXIqIHJl c291cmNlUHJvdmlkZXIsIFBhcmFtZXRlcnMgdXBsb2FkKQogeworICAgIG1fcGl4ZWxzVXBsb2Fk ZWQgKz0gdXBsb2FkLnNvdXJjZVJlY3Qud2lkdGgoKSAqIHVwbG9hZC5zb3VyY2VSZWN0LndpZHRo KCk7CiAgICAgdXBsb2FkLnRleHR1cmUtPnVwZGF0ZVJlY3QocmVzb3VyY2VQcm92aWRlciwgdXBs b2FkLnNvdXJjZVJlY3QsIHVwbG9hZC5kZXN0T2Zmc2V0KTsKIH0KIApAQCAtMTMxLDYgKzE2Niwx NCBAQCB2b2lkIFRocm90dGxlZFRleHR1cmVVcGxvYWRlcjo6cHJvY2Vzc1F1ZXJpZXMoKQogICAg ICAgICBpZiAobV9wZW5kaW5nUXVlcmllcy5maXJzdCgpLT5pc1BlbmRpbmcoKSkKICAgICAgICAg ICAgIGJyZWFrOwogCisgICAgICAgIHVuc2lnbmVkIHVzRWxhcHNlZCA9IG1fcGVuZGluZ1F1ZXJp ZXMuZmlyc3QoKS0+dmFsdWUoKTsKKyAgICAgICAgZG91YmxlIHBpeGVsc1BlclNlY29uZCA9IG1f cGVuZGluZ1F1ZXJpZXMuZmlyc3QoKS0+cGl4ZWxzVXBsb2FkZWQoKSAvICh1c0VsYXBzZWQgKiAx ZS02KTsKKworICAgICAgICAvLyBSZW1vdmUgdGhlIG9sZGVzdCB2YWx1ZXMgZnJvbSBvdXIgaGlz dG9yeSBhbmQgaW5zZXJ0IHRoZSBuZXcgb25lCisgICAgICAgIGlmIChtX3BpeGVsc1BlclNlY29u ZEhpc3Rvcnkuc2l6ZSgpID49IHVwbG9hZEhpc3RvcnlTaXplKQorICAgICAgICAgICAgbV9waXhl bHNQZXJTZWNvbmRIaXN0b3J5LnBvcF9iYWNrKCk7CisgICAgICAgIG1fcGl4ZWxzUGVyU2Vjb25k SGlzdG9yeS5wdXNoX2Zyb250KHBpeGVsc1BlclNlY29uZCk7CisKICAgICAgICAgbV9hdmFpbGFi bGVRdWVyaWVzLmFwcGVuZChtX3BlbmRpbmdRdWVyaWVzLnRha2VGaXJzdCgpKTsKICAgICB9CiB9 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U aHJvdHRsZWRUZXh0dXJlVXBsb2FkZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1Rocm90dGxlZFRleHR1cmVVcGxvYWRlci5oCmluZGV4IDM2MTQ2OGZjODJl ZjUzZWVjYmE0ODQ0Y2VjMjFjNDA1NjI4YjYwNmIuLmIwOTNhZDI3ZmI5Zjg3YWM2YmQ0ZWVjMTNk ZmJmN2I0MGFjMTFhZjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1Rocm90dGxlZFRleHR1cmVVcGxvYWRlci5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1Rocm90dGxlZFRleHR1cmVVcGxvYWRlci5o CkBAIC0yNyw2ICsyNyw3IEBACiAKICNpbmNsdWRlICJUZXh0dXJlVXBsb2FkZXIuaCIKIAorI2lu Y2x1ZGUgPGRlcXVlPgogI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogCiBuYW1lc3BhY2UgV2ViS2l0 IHsKQEAgLTQ5LDYgKzUwLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgflRocm90dGxlZFRleHR1 cmVVcGxvYWRlcigpOwogCiAgICAgdmlydHVhbCBib29sIGlzQnVzeSgpIE9WRVJSSURFOworICAg IHZpcnR1YWwgZG91YmxlIGVzdGltYXRlZFBpeGVsc1BlclNlY29uZCgpIE9WRVJSSURFOwogICAg IHZpcnR1YWwgdm9pZCBiZWdpblVwbG9hZHMoKSBPVkVSUklERTsKICAgICB2aXJ0dWFsIHZvaWQg ZW5kVXBsb2FkcygpIE9WRVJSSURFOwogICAgIHZpcnR1YWwgdm9pZCB1cGxvYWRUZXh0dXJlKEND UmVzb3VyY2VQcm92aWRlciosIFBhcmFtZXRlcnMpIE9WRVJSSURFOwpAQCAtNjEsMTUgKzYzLDE4 IEBAIHByaXZhdGU6CiAgICAgICAgIHZpcnR1YWwgflF1ZXJ5KCk7CiAKICAgICAgICAgdm9pZCBi ZWdpbigpOwotICAgICAgICB2b2lkIGVuZCgpOworICAgICAgICB2b2lkIGVuZChkb3VibGUgcGl4 ZWxzVXBsb2FkZWQpOwogICAgICAgICBib29sIGlzUGVuZGluZygpOwogICAgICAgICB2b2lkIHdh aXQoKTsKKyAgICAgICAgdW5zaWduZWQgdmFsdWUoKTsKKyAgICAgICAgZG91YmxlIHBpeGVsc1Vw bG9hZGVkKCk7CiAKICAgICBwcml2YXRlOgogICAgICAgICBleHBsaWNpdCBRdWVyeShXZWJLaXQ6 OldlYkdyYXBoaWNzQ29udGV4dDNEKik7CiAKICAgICAgICAgV2ViS2l0OjpXZWJHcmFwaGljc0Nv bnRleHQzRCogbV9jb250ZXh0OwogICAgICAgICB1bnNpZ25lZCBtX3F1ZXJ5SWQ7CisgICAgICAg IGRvdWJsZSBtX3BpeGVsc1VwbG9hZGVkOwogICAgIH07CiAKICAgICBUaHJvdHRsZWRUZXh0dXJl VXBsb2FkZXIoV2ViS2l0OjpXZWJHcmFwaGljc0NvbnRleHQzRCopOwpAQCAtODEsNiArODYsOCBA QCBwcml2YXRlOgogICAgIHNpemVfdCBtX21heFBlbmRpbmdRdWVyaWVzOwogICAgIERlcXVlPE93 blB0cjxRdWVyeT4gPiBtX3BlbmRpbmdRdWVyaWVzOwogICAgIERlcXVlPE93blB0cjxRdWVyeT4g PiBtX2F2YWlsYWJsZVF1ZXJpZXM7CisgICAgc3RkOjpkZXF1ZTxkb3VibGU+IG1fcGl4ZWxzUGVy U2Vjb25kSGlzdG9yeTsKKyAgICBkb3VibGUgbV9waXhlbHNVcGxvYWRlZDsKIH07CiAKIH0KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1VudGhy b3R0bGVkVGV4dHVyZVVwbG9hZGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9VbnRocm90dGxlZFRleHR1cmVVcGxvYWRlci5oCmluZGV4IGZhOTY4OTliNjE5 ZWM0ZjZhMjczMzg4ZGZmZDc2NGIwMDA2ZTExODMuLmFmMmVmMjI3YjU1ZTU5NmRmNTQwMWU5MGJh MjI4ZTIzMWRkN2M5ODAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1VudGhyb3R0bGVkVGV4dHVyZVVwbG9hZGVyLmgKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVW50aHJvdHRsZWRUZXh0dXJlVXBsb2Fk ZXIuaApAQCAtNDAsNiArNDAsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB+VW50aHJvdHRsZWRU ZXh0dXJlVXBsb2FkZXIoKSB7IH0KIAogICAgIHZpcnR1YWwgYm9vbCBpc0J1c3koKSBPVkVSUklE RSB7IHJldHVybiBmYWxzZTsgfQorICAgIHZpcnR1YWwgZG91YmxlIGVzdGltYXRlZFBpeGVsc1Bl clNlY29uZCgpIHsgcmV0dXJuIHN0ZDo6bnVtZXJpY19saW1pdHM8ZG91YmxlPjo6bWF4KCk7IH0K ICAgICB2aXJ0dWFsIHZvaWQgYmVnaW5VcGxvYWRzKCkgT1ZFUlJJREUgeyB9CiAgICAgdmlydHVh bCB2b2lkIGVuZFVwbG9hZHMoKSBPVkVSUklERSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgdXBsb2Fk VGV4dHVyZShDQ1Jlc291cmNlUHJvdmlkZXIqIHJlc291cmNlUHJvdmlkZXIsIFBhcmFtZXRlcnMg dXBsb2FkKSBPVkVSUklERSB7IHVwbG9hZC50ZXh0dXJlLT51cGRhdGVSZWN0KHJlc291cmNlUHJv dmlkZXIsIHVwbG9hZC5zb3VyY2VSZWN0LCB1cGxvYWQuZGVzdE9mZnNldCk7IH0KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJU cmVlSG9zdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ0xheWVyVHJlZUhvc3QuY3BwCmluZGV4IDQwMjZlZTgyM2RkYjAxNDcwZTdmNmQ2Nzg2OTJl NjVlNjEzMzE3YjguLjA5Njk2ZjI4Mzg3YjEwYjg4ZDk4ZTE1NDhkNWY3NGNkMzRmZDA3MjggMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND TGF5ZXJUcmVlSG9zdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcApAQCAtODksNiArODksNyBAQCBDQ0xheWVy VHJlZUhvc3Q6OkNDTGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJlZUhvc3RDbGllbnQqIGNsaWVudCwg Y29uc3QgQ0NMYXllclRyZQogICAgICwgbV90cmlnZ2VySWRsZVVwZGF0ZXModHJ1ZSkKICAgICAs IG1fYmFja2dyb3VuZENvbG9yKFNLX0NvbG9yV0hJVEUpCiAgICAgLCBtX2hhc1RyYW5zcGFyZW50 QmFja2dyb3VuZChmYWxzZSkKKyAgICAsIG1fbWF4UGFydGlhbFRleHR1cmVVcGRhdGVzKDApCiAg ICAgLCBtX3BhcnRpYWxUZXh0dXJlVXBkYXRlUmVxdWVzdHMoMCkKIHsKICAgICBBU1NFUlQoQ0NQ cm94eTo6aXNNYWluVGhyZWFkKCkpOwpAQCAtMTQ0LDkgKzE0NSw2IEBAIHZvaWQgQ0NMYXllclRy ZWVIb3N0Ojppbml0aWFsaXplUmVuZGVyZXIoKQogICAgIC8vIFVwZGF0ZSBtX3NldHRpbmdzIGJh c2VkIG9uIGNhcGFiaWxpdGllcyB0aGF0IHdlIGdvdCBiYWNrIGZyb20gdGhlIHJlbmRlcmVyLgog ICAgIG1fc2V0dGluZ3MuYWNjZWxlcmF0ZVBhaW50aW5nID0gbV9wcm94eS0+cmVuZGVyZXJDYXBh YmlsaXRpZXMoKS51c2luZ0FjY2VsZXJhdGVkUGFpbnRpbmc7CiAKLSAgICAvLyBVcGRhdGUgbV9z ZXR0aW5ncyBiYXNlZCBvbiBwYXJ0aWFsIHVwZGF0ZSBjYXBhYmlsaXR5LgotICAgIG1fc2V0dGlu Z3MubWF4UGFydGlhbFRleHR1cmVVcGRhdGVzID0gbWluKG1fc2V0dGluZ3MubWF4UGFydGlhbFRl eHR1cmVVcGRhdGVzLCBtX3Byb3h5LT5tYXhQYXJ0aWFsVGV4dHVyZVVwZGF0ZXMoKSk7Ci0KICAg ICBtX2NvbnRlbnRzVGV4dHVyZU1hbmFnZXIgPSBDQ1ByaW9yaXRpemVkVGV4dHVyZU1hbmFnZXI6 OmNyZWF0ZSgwLCBtX3Byb3h5LT5yZW5kZXJlckNhcGFiaWxpdGllcygpLm1heFRleHR1cmVTaXpl LCBDQ1JlbmRlcmVyOjpDb250ZW50UG9vbCk7CiAgICAgbV9zdXJmYWNlTWVtb3J5UGxhY2Vob2xk ZXIgPSBtX2NvbnRlbnRzVGV4dHVyZU1hbmFnZXItPmNyZWF0ZVRleHR1cmUoSW50U2l6ZSgpLCBH cmFwaGljc0NvbnRleHQzRDo6UkdCQSk7CiAKQEAgLTQ5NSw2ICs0OTMsNyBAQCB2b2lkIENDTGF5 ZXJUcmVlSG9zdDo6dXBkYXRlTGF5ZXJzKExheWVyQ2hyb21pdW0qIHJvb3RMYXllciwgQ0NUZXh0 dXJlVXBkYXRlUXVldQogCiAgICAgLy8gUmVzZXQgcGFydGlhbCB0ZXh0dXJlIHVwZGF0ZSByZXF1 ZXN0cy4KICAgICBtX3BhcnRpYWxUZXh0dXJlVXBkYXRlUmVxdWVzdHMgPSAwOworICAgIG1fbWF4 UGFydGlhbFRleHR1cmVVcGRhdGVzID0gc3RkOjptaW4obV9zZXR0aW5ncy5tYXhQYXJ0aWFsVGV4 dHVyZVVwZGF0ZXMsIG1fcHJveHktPm1heFBhcnRpYWxUZXh0dXJlVXBkYXRlcygpKTsKIAogICAg IGJvb2wgbmVlZE1vcmVVcGRhdGVzID0gcGFpbnRMYXllckNvbnRlbnRzKHVwZGF0ZUxpc3QsIHF1 ZXVlKTsKICAgICBpZiAobV90cmlnZ2VySWRsZVVwZGF0ZXMgJiYgbmVlZE1vcmVVcGRhdGVzKQpA QCAtNzAzLDcgKzcwMiw3IEBAIGJvb2wgQ0NMYXllclRyZWVIb3N0OjpidWZmZXJlZFVwZGF0ZXMo KQogCiBib29sIENDTGF5ZXJUcmVlSG9zdDo6cmVxdWVzdFBhcnRpYWxUZXh0dXJlVXBkYXRlKCkK IHsKLSAgICBpZiAobV9wYXJ0aWFsVGV4dHVyZVVwZGF0ZVJlcXVlc3RzID49IG1fc2V0dGluZ3Mu bWF4UGFydGlhbFRleHR1cmVVcGRhdGVzKQorICAgIGlmIChtX3BhcnRpYWxUZXh0dXJlVXBkYXRl UmVxdWVzdHMgPj0gbV9tYXhQYXJ0aWFsVGV4dHVyZVVwZGF0ZXMpCiAgICAgICAgIHJldHVybiBm YWxzZTsKIAogICAgIG1fcGFydGlhbFRleHR1cmVVcGRhdGVSZXF1ZXN0cysrOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRy ZWVIb3N0LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9D Q0xheWVyVHJlZUhvc3QuaAppbmRleCA3NDI3ODhjNzA2NzgzYmI2MzhmNTNkNjI2ZjJkYzVjYzFl M2E1ODBhLi5hNzJjNzc1NjQzZGQ5MzZiNTA5MmM4MWQ4ODRjNzJjZDExZTVlYTc5IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVy VHJlZUhvc3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ0xheWVyVHJlZUhvc3QuaApAQCAtMzA5LDYgKzMwOSw3IEBAIHByaXZhdGU6CiAgICAg Ym9vbCBtX2hhc1RyYW5zcGFyZW50QmFja2dyb3VuZDsKIAogICAgIFRleHR1cmVMaXN0IG1fZGVs ZXRlVGV4dHVyZUFmdGVyQ29tbWl0TGlzdDsKKyAgICBzaXplX3QgbV9tYXhQYXJ0aWFsVGV4dHVy ZVVwZGF0ZXM7CiAgICAgc2l6ZV90IG1fcGFydGlhbFRleHR1cmVVcGRhdGVSZXF1ZXN0czsKIAog ICAgIHN0YXRpYyBib29sIHNfbmVlZHNGaWx0ZXJDb250ZXh0OwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUZXh0dXJlVXBkYXRlQ29u dHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyLmNwcAppbmRleCA2ZmM3NzFlOTU5MDVlZTNjODdl NjFiMDFmNjg2NjNiMmY5MDYwMWM3Li4yOWZhNTQxYzk1NTE0ODViMWY2N2RkMGFjYzk2YzJmNGQ5 OTk5MzJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9jYy9DQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RleHR1cmVVcGRhdGVDb250cm9sbGVy LmNwcApAQCAtMzAsMTIgKzMwLDE2IEBACiAjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0M0QuaCIK ICNpbmNsdWRlICJUZXh0dXJlQ29waWVyLmgiCiAjaW5jbHVkZSAiVGV4dHVyZVVwbG9hZGVyLmgi CisjaW5jbHVkZSAiVHJhY2VFdmVudC5oIgorI2luY2x1ZGUgPGxpbWl0cz4KICNpbmNsdWRlIDx3 dGYvQ3VycmVudFRpbWUuaD4KIAogbmFtZXNwYWNlIHsKIAotLy8gTnVtYmVyIG9mIHRleHR1cmVz IHRvIHVwZGF0ZSB3aXRoIGVhY2ggY2FsbCB0byB1cGRhdGVNb3JlVGV4dHVyZXNJZkVub3VnaFRp bWVSZW1haW5pbmcoKS4KLXN0YXRpYyBjb25zdCBzaXplX3QgdGV4dHVyZVVwZGF0ZXNQZXJUaWNr ID0gMTI7CitzdGF0aWMgY29uc3Qgc2l6ZV90IHBpeGVsc1BlclRleHR1cmUgPSAyNTYgKiAyNTY7 CisKKy8vIE1pbmltdW0gbnVtYmVyIG9mIHRleHR1cmVzIHRvIHVwZGF0ZSB3aXRoIGVhY2ggY2Fs bCB0byB1cGRhdGVNb3JlVGV4dHVyZXNJZkVub3VnaFRpbWVSZW1haW5pbmcoKS4KK3N0YXRpYyBj b25zdCBzaXplX3QgdGV4dHVyZVVwZGF0ZXNQZXJGdWxsVGlja01pbiA9IDEyOwogCiAvLyBNZWFz dXJlZCBpbiBzZWNvbmRzLgogc3RhdGljIGNvbnN0IGRvdWJsZSB0ZXh0dXJlVXBkYXRlVGlja1Jh dGUgPSAwLjAwNDsKQEAgLTQ3LDU3ICs1MSw1MyBAQCBzdGF0aWMgY29uc3QgaW50IHRleHR1cmVV cGxvYWRGbHVzaFBlcmlvZCA9IDQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotc2l6ZV90IEND VGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6Om1heFBhcnRpYWxUZXh0dXJlVXBkYXRlcygpCitQYXNz T3duUHRyPENDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI+IENDVGV4dHVyZVVwZGF0ZUNvbnRyb2xs ZXI6OmNyZWF0ZShDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyQ2xpZW50KiBjbGllbnQsIENDVGhy ZWFkKiB0aHJlYWQsIFBhc3NPd25QdHI8Q0NUZXh0dXJlVXBkYXRlUXVldWU+IHF1ZXVlLCBDQ1Jl c291cmNlUHJvdmlkZXIqIHJlc291cmNlUHJvdmlkZXIsIFRleHR1cmVDb3BpZXIqIGNvcGllciwg VGV4dHVyZVVwbG9hZGVyKiB1cGxvYWRlcikKIHsKLSAgICByZXR1cm4gdGV4dHVyZVVwZGF0ZXNQ ZXJUaWNrOworICAgIFRSQUNFX0VWRU5UMCgiY2MiLCAiQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxl cjo6Y3JlYXRlIik7CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBDQ1RleHR1cmVVcGRhdGVDb250 cm9sbGVyKGNsaWVudCwgdGhyZWFkLCBxdWV1ZSwgcmVzb3VyY2VQcm92aWRlciwgY29waWVyLCB1 cGxvYWRlcikpOwogfQogCiB2b2lkIENDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OnVwZGF0ZVRl eHR1cmVzKENDUmVzb3VyY2VQcm92aWRlciogcmVzb3VyY2VQcm92aWRlciwgVGV4dHVyZUNvcGll ciogY29waWVyLCBUZXh0dXJlVXBsb2FkZXIqIHVwbG9hZGVyLCBDQ1RleHR1cmVVcGRhdGVRdWV1 ZSogcXVldWUsIHNpemVfdCBjb3VudCkKIHsKLSAgICBpZiAocXVldWUtPmZ1bGxVcGxvYWRTaXpl KCkgfHwgcXVldWUtPnBhcnRpYWxVcGxvYWRTaXplKCkpIHsKLSAgICAgICAgaWYgKHVwbG9hZGVy LT5pc0J1c3koKSkKLSAgICAgICAgICAgIHJldHVybjsKKyAgICBUUkFDRV9FVkVOVDIoImNjIiwg IkNDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OnVwZGF0ZVRleHR1cmVzIiwgImZ1bGwiLCBpbnQo cXVldWUtPmZ1bGxVcGxvYWRTaXplKCkpLCAicGFydGlhbCIsIGludChxdWV1ZS0+cGFydGlhbFVw bG9hZFNpemUoKSkpOwogCisgICAgaWYgKHF1ZXVlLT5mdWxsVXBsb2FkU2l6ZSgpIHx8IHF1ZXVl LT5wYXJ0aWFsVXBsb2FkU2l6ZSgpKSB7CiAgICAgICAgIHVwbG9hZGVyLT5iZWdpblVwbG9hZHMo KTsKIAogICAgICAgICBzaXplX3QgZnVsbFVwbG9hZENvdW50ID0gMDsKLSAgICAgICAgd2hpbGUg KHF1ZXVlLT5mdWxsVXBsb2FkU2l6ZSgpICYmIGZ1bGxVcGxvYWRDb3VudCA8IGNvdW50KSB7Cisg ICAgICAgIGJvb2wgdXBsb2FkTW9yZSA9IHF1ZXVlLT5mdWxsVXBsb2FkU2l6ZSgpICYmIGZ1bGxV cGxvYWRDb3VudCA8IGNvdW50OworICAgICAgICB3aGlsZSAodXBsb2FkTW9yZSkgewogICAgICAg ICAgICAgdXBsb2FkZXItPnVwbG9hZFRleHR1cmUocmVzb3VyY2VQcm92aWRlciwgcXVldWUtPnRh a2VGaXJzdEZ1bGxVcGxvYWQoKSk7CiAgICAgICAgICAgICBmdWxsVXBsb2FkQ291bnQrKzsKLSAg ICAgICAgICAgIGlmICghKGZ1bGxVcGxvYWRDb3VudCAlIHRleHR1cmVVcGxvYWRGbHVzaFBlcmlv ZCkpCisgICAgICAgICAgICB1cGxvYWRNb3JlID0gcXVldWUtPmZ1bGxVcGxvYWRTaXplKCkgJiYg ZnVsbFVwbG9hZENvdW50IDwgY291bnQ7CisKKyAgICAgICAgICAgIC8vIEZsdXNoIHBlcmlvZGlj YWxseSwgYnV0IGRlZmZlciBvdXIgbGFzdCBmbHVzaCB1bnRpbCBhZnRlciB1cGxvYWRlci0+ZW5k VXBsb2FkcygpCisgICAgICAgICAgICAvLyBpbiBvcmRlciB0byBrZWVwIHRoZSBxdWVyeSBhc3Nv Y2lhdGVkIHdpdGggZW5kVXBsb2FkcyBncm91cGVkIHdpdGggb3VyIGxhc3QgdGV4dHVyZSB1cGxv YWQuCisgICAgICAgICAgICBpZiAoIShmdWxsVXBsb2FkQ291bnQgJSB0ZXh0dXJlVXBsb2FkRmx1 c2hQZXJpb2QpICYmIHVwbG9hZE1vcmUpCiAgICAgICAgICAgICAgICAgcmVzb3VyY2VQcm92aWRl ci0+c2hhbGxvd0ZsdXNoSWZTdXBwb3J0ZWQoKTsKICAgICAgICAgfQogCi0gICAgICAgIC8vIE1h a2Ugc3VyZSB0aGVyZSBhcmUgbm8gZGFuZ2xpbmcgdXBsb2FkcyB3aXRob3V0IGEgZmx1c2guCi0g ICAgICAgIGlmIChmdWxsVXBsb2FkQ291bnQgJSB0ZXh0dXJlVXBsb2FkRmx1c2hQZXJpb2QpCi0g ICAgICAgICAgICByZXNvdXJjZVByb3ZpZGVyLT5zaGFsbG93Rmx1c2hJZlN1cHBvcnRlZCgpOwot Ci0gICAgICAgIGJvb2wgbW9yZVVwbG9hZHMgPSBxdWV1ZS0+ZnVsbFVwbG9hZFNpemUoKTsKLQot ICAgICAgICBBU1NFUlQocXVldWUtPnBhcnRpYWxVcGxvYWRTaXplKCkgPD0gY291bnQpOwotICAg ICAgICAvLyBXZSBuZWVkIGFub3RoZXIgdXBkYXRlIGJhdGNoIGlmIHRoZSBudW1iZXIgb2YgdXBk YXRlcyByZW1haW5pbmcKLSAgICAgICAgLy8gaW4gfGNvdW50fCBpcyBncmVhdGVyIHRoYW4gdGhl IHJlbWFpbmluZyBwYXJ0aWFsIGVudHJpZXMuCi0gICAgICAgIGlmICgoY291bnQgLSBmdWxsVXBs b2FkQ291bnQpIDwgcXVldWUtPnBhcnRpYWxVcGxvYWRTaXplKCkpCi0gICAgICAgICAgICBtb3Jl VXBsb2FkcyA9IHRydWU7Ci0KLSAgICAgICAgaWYgKG1vcmVVcGxvYWRzKSB7CisgICAgICAgIGJv b2wgbmVlZEFub3RoZXJUaWNrID0gcXVldWUtPmZ1bGxVcGxvYWRTaXplKCkgfHwgKChjb3VudCAt IGZ1bGxVcGxvYWRDb3VudCkgPCBxdWV1ZS0+cGFydGlhbFVwbG9hZFNpemUoKSk7CisgICAgICAg IGlmIChuZWVkQW5vdGhlclRpY2spIHsKICAgICAgICAgICAgIHVwbG9hZGVyLT5lbmRVcGxvYWRz KCk7CisgICAgICAgICAgICByZXNvdXJjZVByb3ZpZGVyLT5zaGFsbG93Rmx1c2hJZlN1cHBvcnRl ZCgpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CisgICAgICAgIHJlc291cmNlUHJv dmlkZXItPnNoYWxsb3dGbHVzaElmU3VwcG9ydGVkKCk7CiAKICAgICAgICAgc2l6ZV90IHBhcnRp YWxVcGxvYWRDb3VudCA9IDA7CiAgICAgICAgIHdoaWxlIChxdWV1ZS0+cGFydGlhbFVwbG9hZFNp emUoKSkgewogICAgICAgICAgICAgdXBsb2FkZXItPnVwbG9hZFRleHR1cmUocmVzb3VyY2VQcm92 aWRlciwgcXVldWUtPnRha2VGaXJzdFBhcnRpYWxVcGxvYWQoKSk7CiAgICAgICAgICAgICBwYXJ0 aWFsVXBsb2FkQ291bnQrKzsKLSAgICAgICAgICAgIGlmICghKHBhcnRpYWxVcGxvYWRDb3VudCAl IHRleHR1cmVVcGxvYWRGbHVzaFBlcmlvZCkpCisgICAgICAgICAgICAKKyAgICAgICAgICAgIC8v IEZsdXNoIHBlcmlvZGljYWxseSwgYnV0IGRlZmZlciBvdXIgbGFzdCBmbHVzaCB1bnRpbCBhZnRl ciB1cGxvYWRlci0+ZW5kVXBsb2FkcygpCisgICAgICAgICAgICAvLyBpbiBvcmRlciB0byBrZWVw IHRoZSBxdWVyeSBhc3NvY2lhdGVkIHdpdGggZW5kVXBsb2FkcyBncm91cGVkIHdpdGggb3VyIGxh c3QgdGV4dHVyZSB1cGxvYWQuCisgICAgICAgICAgICBpZiAoIShwYXJ0aWFsVXBsb2FkQ291bnQg JSB0ZXh0dXJlVXBsb2FkRmx1c2hQZXJpb2QpICYmIHF1ZXVlLT5wYXJ0aWFsVXBsb2FkU2l6ZSgp KQogICAgICAgICAgICAgICAgIHJlc291cmNlUHJvdmlkZXItPnNoYWxsb3dGbHVzaElmU3VwcG9y dGVkKCk7CiAgICAgICAgIH0KIAotICAgICAgICAvLyBNYWtlIHN1cmUgdGhlcmUgYXJlIG5vIGRh bmdsaW5nIHBhcnRpYWwgdXBsb2FkcyB3aXRob3V0IGEgZmx1c2guCi0gICAgICAgIGlmIChwYXJ0 aWFsVXBsb2FkQ291bnQgJSB0ZXh0dXJlVXBsb2FkRmx1c2hQZXJpb2QpCi0gICAgICAgICAgICBy ZXNvdXJjZVByb3ZpZGVyLT5zaGFsbG93Rmx1c2hJZlN1cHBvcnRlZCgpOwotCiAgICAgICAgIHVw bG9hZGVyLT5lbmRVcGxvYWRzKCk7CisgICAgICAgIHJlc291cmNlUHJvdmlkZXItPnNoYWxsb3dG bHVzaElmU3VwcG9ydGVkKCk7CiAgICAgfQogCiAgICAgc2l6ZV90IGNvcHlDb3VudCA9IDA7CkBA IC0xMTMsMTMgKzExMywxNiBAQCB2b2lkIENDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OnVwZGF0 ZVRleHR1cmVzKENDUmVzb3VyY2VQcm92aWRlciogcmVzb3VyY2VQcm92aQogICAgICAgICBjb3Bp ZXItPmZsdXNoKCk7CiB9CiAKLUNDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OkNDVGV4dHVyZVVw ZGF0ZUNvbnRyb2xsZXIoQ0NUaHJlYWQqIHRocmVhZCwgUGFzc093blB0cjxDQ1RleHR1cmVVcGRh dGVRdWV1ZT4gcXVldWUsIENDUmVzb3VyY2VQcm92aWRlciogcmVzb3VyY2VQcm92aWRlciwgVGV4 dHVyZUNvcGllciogY29waWVyLCBUZXh0dXJlVXBsb2FkZXIqIHVwbG9hZGVyKQotICAgIDogbV90 aW1lcihhZG9wdFB0cihuZXcgQ0NUaW1lcih0aHJlYWQsIHRoaXMpKSkKK0NDVGV4dHVyZVVwZGF0 ZUNvbnRyb2xsZXI6OkNDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXIoQ0NUZXh0dXJlVXBkYXRlQ29u dHJvbGxlckNsaWVudCogY2xpZW50LCBDQ1RocmVhZCogdGhyZWFkLCBQYXNzT3duUHRyPENDVGV4 dHVyZVVwZGF0ZVF1ZXVlPiBxdWV1ZSwgQ0NSZXNvdXJjZVByb3ZpZGVyKiByZXNvdXJjZVByb3Zp ZGVyLCBUZXh0dXJlQ29waWVyKiBjb3BpZXIsIFRleHR1cmVVcGxvYWRlciogdXBsb2FkZXIpCisg ICAgOiBtX2NsaWVudChjbGllbnQpCisgICAgLCBtX3RpbWVyKGFkb3B0UHRyKG5ldyBDQ1RpbWVy KHRocmVhZCwgdGhpcykpKQogICAgICwgbV9xdWV1ZShxdWV1ZSkKICAgICAsIG1fcmVzb3VyY2VQ cm92aWRlcihyZXNvdXJjZVByb3ZpZGVyKQogICAgICwgbV9jb3BpZXIoY29waWVyKQogICAgICwg bV91cGxvYWRlcih1cGxvYWRlcikKICAgICAsIG1fbW9ub3RvbmljVGltZUxpbWl0KDApCisgICAg LCBtX3RpY2tQZXJpb2QodGV4dHVyZVVwZGF0ZVRpY2tSYXRlKQorICAgICwgbV90ZXh0dXJlVXBk YXRlc1BlclRpY2soMCkKICAgICAsIG1fZmlyc3RVcGRhdGVBdHRlbXB0KHRydWUpCiB7CiB9CkBA IC0xMzUsNiArMTM4LDggQEAgYm9vbCBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjpoYXNNb3Jl VXBkYXRlcygpIGNvbnN0CiAKIHZvaWQgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRl TW9yZVRleHR1cmVzKGRvdWJsZSBtb25vdG9uaWNUaW1lTGltaXQpCiB7CisgICAgVFJBQ0VfRVZF TlQyKCJjYyIsICJDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjp1cGRhdGVNb3JlVGV4dHVyZXMi LCAiVXBkYXRlc1BlclRpY2siLCAoaW50KW1fdGV4dHVyZVVwZGF0ZXNQZXJUaWNrLCAiVGlja1Bl cmlvZCIsIG1fdGlja1BlcmlvZCkKKwogICAgIG1fbW9ub3RvbmljVGltZUxpbWl0ID0gbW9ub3Rv bmljVGltZUxpbWl0OwogCiAgICAgaWYgKCFtX3F1ZXVlLT5oYXNNb3JlVXBkYXRlcygpKQpAQCAt MTQ2LDEyICsxNTEsMTggQEAgdm9pZCBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjp1cGRhdGVN b3JlVGV4dHVyZXMoZG91YmxlIG1vbm90b25pY1RpbWVMaW1pdCkKICAgICBpZiAobV9maXJzdFVw ZGF0ZUF0dGVtcHQpIHsKICAgICAgICAgdXBkYXRlTW9yZVRleHR1cmVzSWZFbm91Z2hUaW1lUmVt YWluaW5nKCk7CiAgICAgICAgIG1fZmlyc3RVcGRhdGVBdHRlbXB0ID0gZmFsc2U7Ci0gICAgfSBl bHNlCi0gICAgICAgIHVwZGF0ZU1vcmVUZXh0dXJlc05vdygpOworICAgIH0gZWxzZSB7CisgICAg ICAgIC8vIFdlIGFsbG93IGluZmluaXRlIHRpbWUgaGVyZSB0byB1bmJsb2NrIHRoZSBwYXJ0aWFs IHRleHR1cmUgdXBsb2FkcywKKyAgICAgICAgLy8ganVzdCBpbiBjYXNlIHRoZSBlc3RpbWF0ZWQg YmFuZHdpZHRoIGlzIGxvd2VyIG5vdyB0aGFuIHdoZW4gdGhleSB3ZXJlIGFkZGVkLgorICAgICAg ICB1cGRhdGVNb3JlVGV4dHVyZXNOb3coc3RkOjpudW1lcmljX2xpbWl0czxkb3VibGU+OjptYXgo KSk7CisgICAgfQorCiB9CiAKIHZvaWQgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6b25UaW1l ckZpcmVkKCkKIHsKKyAgICBUUkFDRV9FVkVOVDIoImNjIiwgIkNDVGV4dHVyZVVwZGF0ZUNvbnRy b2xsZXI6Om9uVGltZXJGaXJlZCIsICJVcGRhdGVzUGVyVGljayIsIChpbnQpbV90ZXh0dXJlVXBk YXRlc1BlclRpY2ssICJUaWNrUGVyaW9kIiwgbV90aWNrUGVyaW9kKQorCiAgICAgaWYgKCFtX3F1 ZXVlLT5oYXNNb3JlVXBkYXRlcygpKQogICAgICAgICByZXR1cm47CiAKQEAgLTE2NSwyNSArMTc2 LDc4IEBAIGRvdWJsZSBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjptb25vdG9uaWNUaW1lTm93 KCkgY29uc3QKIAogZG91YmxlIENDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OnVwZGF0ZU1vcmVU ZXh0dXJlc1RpbWUoKSBjb25zdAogewotICAgIHJldHVybiB0ZXh0dXJlVXBkYXRlVGlja1JhdGU7 CisgICAgcmV0dXJuIG1fdGlja1BlcmlvZDsKIH0KIAogc2l6ZV90IENDVGV4dHVyZVVwZGF0ZUNv bnRyb2xsZXI6OnVwZGF0ZU1vcmVUZXh0dXJlc1NpemUoKSBjb25zdAogewotICAgIHJldHVybiB0 ZXh0dXJlVXBkYXRlc1BlclRpY2s7CisgICAgcmV0dXJuIG1fdGV4dHVyZVVwZGF0ZXNQZXJUaWNr OworfQorCitzaXplX3QgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6bWF4UGFydGlhbFRleHR1 cmVVcGRhdGVzKCkgY29uc3QKK3sKKyAgICBkb3VibGUgdGV4dHVyZXNQZXJTZWNvbmQgPSBtX3Vw bG9hZGVyLT5lc3RpbWF0ZWRQaXhlbHNQZXJTZWNvbmQoKSAvIHBpeGVsc1BlclRleHR1cmU7CisK KyAgICByZXR1cm4gc3RkOjptYXgodGV4dHVyZVVwZGF0ZXNQZXJGdWxsVGlja01pbiwKKyAgICAg ICAgICAgICAgICAgICAgKHNpemVfdCkgZmxvb3IodGV4dHVyZVVwZGF0ZVRpY2tSYXRlIC8gdGV4 dHVyZXNQZXJTZWNvbmQpKTsKK30KKworLy8gVGhlIGdvYWwgb2YgdGhpcyBtZXRob2QgaXMgdG8g b3B0aW1pemUgdGhlIHZhbHVlcyBvZiBtX3RpY2tQZXJpb2QKKy8vIGFuZCBtX3RleHR1cmVVcGRh dGVzUGVyVGljayBpbiBhbiBhdHRlbXB0IHRvOgorLy8gMSkgQXZvaWQgdGlja2luZyB0b28gb2Z0 ZW4KKy8vIDIpIE1pbmltaXplIHRoZSBhbW91bnQgb2YgaWRsZSB0aW1lIHRoYXQgd2UgYXJlbid0 IHVwbG9hZGluZy4KK3ZvaWQgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRlVGV4dHVy ZUNvdW50QW5kVGlja1BlcmlvZChkb3VibGUgdGltZUJlZm9yZVZzeW5jKQoreworICAgIG1fdGlj a1BlcmlvZCA9IHRleHR1cmVVcGRhdGVUaWNrUmF0ZTsKKworICAgIC8vIERldGVybWluZSBob3cg bWFueSB1cGxvYWRzIHdlIHdpbGwgZG8gZm9yIHRoaXMgdGljay4KKyAgICBpZiAobV91cGxvYWRl ci0+aXNCdXN5KCkpIHsKKyAgICAgICAgbV90ZXh0dXJlVXBkYXRlc1BlclRpY2sgPSAwOworICAg IH0gZWxzZSBpZiAobV9xdWV1ZS0+ZnVsbFVwbG9hZFNpemUoKSkgeworICAgICAgICAvLyBJZiB3 ZSBoYXZlIGZ1bGwgdXBsb2Fkcywgd2UgY2FuIHNwbGl0IHRoZW0gdXAgYXMgd2UgcGxlYXNlLgor ICAgICAgICBkb3VibGUgdGV4dHVyZXNQZXJTZWNvbmQgPSBtX3VwbG9hZGVyLT5lc3RpbWF0ZWRQ aXhlbHNQZXJTZWNvbmQoKSAvIHBpeGVsc1BlclRleHR1cmU7CisgICAgICAgIGlmICh0aW1lQmVm b3JlVnN5bmMgPiBtX3RpY2tQZXJpb2QpIHsKKyAgICAgICAgICAgIG1fdGV4dHVyZVVwZGF0ZXNQ ZXJUaWNrID0gc3RkOjptYXgodGV4dHVyZVVwZGF0ZXNQZXJGdWxsVGlja01pbiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKHNpemVfdCkgY2VpbCh0ZXh0 dXJlc1BlclNlY29uZCAqIG1fdGlja1BlcmlvZCkpOworICAgICAgICB9IGVsc2UKKyAgICAgICAg ICAgIG1fdGV4dHVyZVVwZGF0ZXNQZXJUaWNrID0gMDsKKyAgICB9IGVsc2UgaWYgKG1fcXVldWUt PnBhcnRpYWxVcGxvYWRTaXplKCkpIHsKKyAgICAgICAgLy8gSWYgd2Ugb25seSBoYXZlIHBhcnRp YWxzLCB3ZSBtdXN0IHVwbG9hZCB0aGVtIGFsbCBhdCBvbmNlIG90aGVyd2lzZSB3ZSB3aWxsIGJs b2NrIGRyYXdpbmcuCisgICAgICAgIGRvdWJsZSBzZWNvbmRzUGVyVGV4dHVyZSA9IHBpeGVsc1Bl clRleHR1cmUgLyBtX3VwbG9hZGVyLT5lc3RpbWF0ZWRQaXhlbHNQZXJTZWNvbmQoKTsKKyAgICAg ICAgZG91YmxlIHRpbWVUb1VwbG9hZEFsbFBhcnRpYWxzID0gbV9xdWV1ZS0+cGFydGlhbFVwbG9h ZFNpemUoKSAqIHNlY29uZHNQZXJUZXh0dXJlOworICAgICAgICBpZiAodGltZUJlZm9yZVZzeW5j ID4gdGltZVRvVXBsb2FkQWxsUGFydGlhbHMpCisgICAgICAgICAgICBtX3RleHR1cmVVcGRhdGVz UGVyVGljayA9IG1fcXVldWUtPnBhcnRpYWxVcGxvYWRTaXplKCk7CisgICAgICAgIGVsc2UKKyAg ICAgICAgICAgIG1fdGV4dHVyZVVwZGF0ZXNQZXJUaWNrID0gMDsKKyAgICB9IGVsc2UKKyAgICAg ICAgbV90ZXh0dXJlVXBkYXRlc1BlclRpY2sgPSAwOwogfQogCiB2b2lkIENDVGV4dHVyZVVwZGF0 ZUNvbnRyb2xsZXI6OnVwZGF0ZU1vcmVUZXh0dXJlc0lmRW5vdWdoVGltZVJlbWFpbmluZygpCiB7 Ci0gICAgYm9vbCBoYXNUaW1lUmVtYWluaW5nID0gbW9ub3RvbmljVGltZU5vdygpIDwgbV9tb25v dG9uaWNUaW1lTGltaXQgLSB1cGRhdGVNb3JlVGV4dHVyZXNUaW1lKCk7Ci0gICAgaWYgKGhhc1Rp bWVSZW1haW5pbmcpCi0gICAgICAgIHVwZGF0ZU1vcmVUZXh0dXJlc05vdygpOworICAgIFRSQUNF X0VWRU5UMigiY2MiLCAiQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRlTW9yZVRleHR1 cmVzSWZFbm91Z2hUaW1lUmVtYWluaW5nIiwgIlVwZGF0ZXNQZXJUaWNrIiwgKGludCltX3RleHR1 cmVVcGRhdGVzUGVyVGljaywgIlRpY2tQZXJpb2QiLCBtX3RpY2tQZXJpb2QpOworICAgIHVwZGF0 ZU1vcmVUZXh0dXJlc05vdyhtX21vbm90b25pY1RpbWVMaW1pdCAtIG1vbm90b25pY1RpbWVOb3co KSk7CiB9CiAKLXZvaWQgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRlTW9yZVRleHR1 cmVzTm93KCkKK3ZvaWQgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6dXBkYXRlTW9yZVRleHR1 cmVzTm93KGRvdWJsZSB0aW1lQmVmb3JlVnN5bmMpCiB7CisgICAgdXBkYXRlVGV4dHVyZUNvdW50 QW5kVGlja1BlcmlvZCh0aW1lQmVmb3JlVnN5bmMpOworCisgICAgVFJBQ0VfRVZFTlQyKCJjYyIs ICJDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjp1cGRhdGVNb3JlVGV4dHVyZXNOb3ciLCAiVXBk YXRlc1BlclRpY2siLCAoaW50KW1fdGV4dHVyZVVwZGF0ZXNQZXJUaWNrLCAiVGlja1BlcmlvZCIs IG1fdGlja1BlcmlvZCk7CisKKyAgICBpZiAoIXVwZGF0ZU1vcmVUZXh0dXJlc1NpemUoKSkKKyAg ICAgICByZXR1cm47CisKICAgICBtX3RpbWVyLT5zdGFydE9uZVNob3QodXBkYXRlTW9yZVRleHR1 cmVzVGltZSgpKTsKKwogICAgIHVwZGF0ZVRleHR1cmVzKG1fcmVzb3VyY2VQcm92aWRlciwgbV9j b3BpZXIsIG1fdXBsb2FkZXIsIG1fcXVldWUuZ2V0KCksIHVwZGF0ZU1vcmVUZXh0dXJlc1NpemUo KSk7CisKKyAgICAvLyBVcGRhdGUgbWF4UGFydGlhbFRleHR1cmVVcGRhdGVzIGF0IHRoZSBlbmQg b2YgYSBiYXRjaCBvZiB1cGxvYWRzLgorICAgIC8vIFRoaXMgd2lsbCBldmVudHVhbGx5IG1ha2Ug aXQncyB3YXkgdG8gdGhlIG1haW4gdGhyZWFkLiBXZSB3aWxsIG5vdCBiZSBwZXJmZWN0bHkKKyAg ICAvLyBzeW5jaHJvbml6ZWQgd2l0aCB0aGUgbWFpbiB0aHJlYWQsIHNvIHdlIG5lZWQgdG8gYWxs b3cgZm9yIHRoZSBudW1iZXIgb2YgcGFydGlhbAorICAgIC8vIHRleHR1cmUgdXBkYXRlcyBiZWlu ZyBoaWdoZXIgdGhhbiB0aGUgY3VycmVudCB2YWx1ZSBvZiBtYXhQYXJ0aWFsVGV4dHVyZVVwZGF0 ZXMuCisgICAgaWYgKCFtX3F1ZXVlLT5oYXNNb3JlVXBkYXRlcygpKQorICAgICAgICBtX2NsaWVu dC0+c2V0TWF4UGFydGlhbFRleHR1cmVVcGRhdGVzT25JbXBsVGhyZWFkKG1heFBhcnRpYWxUZXh0 dXJlVXBkYXRlcygpKTsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlci5oIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUZXh0dXJlVXBkYXRl Q29udHJvbGxlci5oCmluZGV4IGRkNzU4YmViNGQ5ZmNkODY2ZTE4Yzg0N2NjZDBhZjI4OWJhOTVi ZDEuLmVhMzg5ZDVjYjQ3Y2JjOWRiYWZkMGE0MTc1MWVkOTdhYTIzMDYyNDIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGV4dHVyZVVw ZGF0ZUNvbnRyb2xsZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9jYy9DQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyLmgKQEAgLTM2LDE0ICszNiwxNSBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBjbGFzcyBUZXh0dXJlQ29waWVyOwogY2xhc3MgVGV4dHVy ZVVwbG9hZGVyOwogCitjbGFzcyBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyQ2xpZW50IHsKK3B1 YmxpYzoKKyAgICB2aXJ0dWFsIHZvaWQgc2V0TWF4UGFydGlhbFRleHR1cmVVcGRhdGVzT25JbXBs VGhyZWFkKHNpemVfdCkgPSAwOworfTsKKwogY2xhc3MgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxl ciA6IHB1YmxpYyBDQ1RpbWVyQ2xpZW50IHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShDQ1Rl eHR1cmVVcGRhdGVDb250cm9sbGVyKTsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc093blB0cjxD Q1RleHR1cmVVcGRhdGVDb250cm9sbGVyPiBjcmVhdGUoQ0NUaHJlYWQqIHRocmVhZCwgUGFzc093 blB0cjxDQ1RleHR1cmVVcGRhdGVRdWV1ZT4gcXVldWUsIENDUmVzb3VyY2VQcm92aWRlciogcmVz b3VyY2VQcm92aWRlciwgVGV4dHVyZUNvcGllciogY29waWVyLCBUZXh0dXJlVXBsb2FkZXIqIHVw bG9hZGVyKQotICAgIHsKLSAgICAgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBDQ1RleHR1cmVVcGRh dGVDb250cm9sbGVyKHRocmVhZCwgcXVldWUsIHJlc291cmNlUHJvdmlkZXIsIGNvcGllciwgdXBs b2FkZXIpKTsKLSAgICB9Ci0gICAgc3RhdGljIHNpemVfdCBtYXhQYXJ0aWFsVGV4dHVyZVVwZGF0 ZXMoKTsKKyAgICBzdGF0aWMgUGFzc093blB0cjxDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyPiBj cmVhdGUoQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlckNsaWVudCosIENDVGhyZWFkKiwgUGFzc093 blB0cjxDQ1RleHR1cmVVcGRhdGVRdWV1ZT4sIENDUmVzb3VyY2VQcm92aWRlciosIFRleHR1cmVD b3BpZXIqLCBUZXh0dXJlVXBsb2FkZXIqKTsKICAgICBzdGF0aWMgdm9pZCB1cGRhdGVUZXh0dXJl cyhDQ1Jlc291cmNlUHJvdmlkZXIqLCBUZXh0dXJlQ29waWVyKiwgVGV4dHVyZVVwbG9hZGVyKiwg Q0NUZXh0dXJlVXBkYXRlUXVldWUqLCBzaXplX3QgY291bnQpOwogCiAgICAgdmlydHVhbCB+Q0NU ZXh0dXJlVXBkYXRlQ29udHJvbGxlcigpOwpAQCAtNjAsMTEgKzYxLDE1IEBAIHB1YmxpYzoKICAg ICB2aXJ0dWFsIHNpemVfdCB1cGRhdGVNb3JlVGV4dHVyZXNTaXplKCkgY29uc3Q7CiAKIHByb3Rl Y3RlZDoKLSAgICBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyKENDVGhyZWFkKiwgUGFzc093blB0 cjxDQ1RleHR1cmVVcGRhdGVRdWV1ZT4sIENDUmVzb3VyY2VQcm92aWRlciosIFRleHR1cmVDb3Bp ZXIqLCBUZXh0dXJlVXBsb2FkZXIqKTsKKyAgICBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyKEND VGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXJDbGllbnQqLCBDQ1RocmVhZCosIFBhc3NPd25QdHI8Q0NU ZXh0dXJlVXBkYXRlUXVldWU+LCBDQ1Jlc291cmNlUHJvdmlkZXIqLCBUZXh0dXJlQ29waWVyKiwg VGV4dHVyZVVwbG9hZGVyKik7CisKKyAgICBzaXplX3QgbWF4UGFydGlhbFRleHR1cmVVcGRhdGVz KCkgY29uc3Q7CisgICAgdm9pZCB1cGRhdGVUZXh0dXJlQ291bnRBbmRUaWNrUGVyaW9kKGRvdWJs ZSB0aW1lQmVmb3JlVnN5bmMpOwogCiAgICAgdm9pZCB1cGRhdGVNb3JlVGV4dHVyZXNJZkVub3Vn aFRpbWVSZW1haW5pbmcoKTsKLSAgICB2b2lkIHVwZGF0ZU1vcmVUZXh0dXJlc05vdygpOworICAg IHZvaWQgdXBkYXRlTW9yZVRleHR1cmVzTm93KGRvdWJsZSB0aW1lQmVmb3JlVnN5bmMpOwogCisg ICAgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlckNsaWVudCAqbV9jbGllbnQ7CiAgICAgT3duUHRy PENDVGltZXI+IG1fdGltZXI7CiAgICAgT3duUHRyPENDVGV4dHVyZVVwZGF0ZVF1ZXVlPiBtX3F1 ZXVlOwogICAgIGJvb2wgbV9jb250ZW50c1RleHR1cmVzUHVyZ2VkOwpAQCAtNzIsNiArNzcsOCBA QCBwcm90ZWN0ZWQ6CiAgICAgVGV4dHVyZUNvcGllciogbV9jb3BpZXI7CiAgICAgVGV4dHVyZVVw bG9hZGVyKiBtX3VwbG9hZGVyOwogICAgIGRvdWJsZSBtX21vbm90b25pY1RpbWVMaW1pdDsKKyAg ICBkb3VibGUgbV90aWNrUGVyaW9kOworICAgIHNpemVfdCBtX3RleHR1cmVVcGRhdGVzUGVyVGlj azsKICAgICBib29sIG1fZmlyc3RVcGRhdGVBdHRlbXB0OwogfTsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVh ZFByb3h5LmNwcAppbmRleCBiM2FmNThlOTMyYWUzMmI1ZDJiMjg4MjIwZTExNjdkODEwNjE3MGI0 Li40ZTkwZmIyZjUxZjAzNjIyMDdhMmQxMjk0MjBjZWMxZmM3YmQ3ZWQ1IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9D Q1RocmVhZFByb3h5LmNwcApAQCAtNjE3LDcgKzYxNyw3IEBAIHZvaWQgQ0NUaHJlYWRQcm94eTo6 YmVnaW5GcmFtZUNvbXBsZXRlT25JbXBsVGhyZWFkKENDQ29tcGxldGlvbkV2ZW50KiBjb21wbGV0 aW9uCiAgICAgfSBlbHNlCiAgICAgICAgIG1fcmVzZXRDb250ZW50c1RleHR1cmVzUHVyZ2VkQWZ0 ZXJDb21taXRPbkltcGxUaHJlYWQgPSB0cnVlOwogCi0gICAgbV9jdXJyZW50VGV4dHVyZVVwZGF0 ZUNvbnRyb2xsZXJPbkltcGxUaHJlYWQgPSBDQ1RleHR1cmVVcGRhdGVDb250cm9sbGVyOjpjcmVh dGUoQ0NQcm94eTo6aW1wbFRocmVhZCgpLCBxdWV1ZSwgbV9sYXllclRyZWVIb3N0SW1wbC0+cmVz b3VyY2VQcm92aWRlcigpLCBtX2xheWVyVHJlZUhvc3RJbXBsLT5yZW5kZXJlcigpLT50ZXh0dXJl Q29waWVyKCksIG1fbGF5ZXJUcmVlSG9zdEltcGwtPnJlbmRlcmVyKCktPnRleHR1cmVVcGxvYWRl cigpKTsKKyAgICBtX2N1cnJlbnRUZXh0dXJlVXBkYXRlQ29udHJvbGxlck9uSW1wbFRocmVhZCA9 IENDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXI6OmNyZWF0ZSh0aGlzLCBDQ1Byb3h5OjppbXBsVGhy ZWFkKCksIHF1ZXVlLCBtX2xheWVyVHJlZUhvc3RJbXBsLT5yZXNvdXJjZVByb3ZpZGVyKCksIG1f bGF5ZXJUcmVlSG9zdEltcGwtPnJlbmRlcmVyKCktPnRleHR1cmVDb3BpZXIoKSwgbV9sYXllclRy ZWVIb3N0SW1wbC0+cmVuZGVyZXIoKS0+dGV4dHVyZVVwbG9hZGVyKCkpOwogICAgIG1fY29tbWl0 Q29tcGxldGlvbkV2ZW50T25JbXBsVGhyZWFkID0gY29tcGxldGlvbjsKIAogICAgIG1fc2NoZWR1 bGVyT25JbXBsVGhyZWFkLT5iZWdpbkZyYW1lQ29tcGxldGUoKTsKQEAgLTg1NSw2ICs4NTUsMTgg QEAgdm9pZCBDQ1RocmVhZFByb3h5Ojp0cnlUb1JlY3JlYXRlQ29udGV4dCgpCiAgICAgICAgIG1f Y29udGV4dFJlY3JlYXRpb25UaW1lci5jbGVhcigpOwogfQogCit2b2lkIENDVGhyZWFkUHJveHk6 OnNldE1heFBhcnRpYWxUZXh0dXJlVXBkYXRlc09uSW1wbFRocmVhZChzaXplX3QgbWF4KQorewor ICAgIEFTU0VSVChpc0ltcGxUaHJlYWQoKSk7CisgICAgbV9tYWluVGhyZWFkUHJveHktPnBvc3RU YXNrKGNyZWF0ZUNDVGhyZWFkVGFzayh0aGlzLCAmQ0NUaHJlYWRQcm94eTo6c2V0TWF4UGFydGlh bFRleHR1cmVVcGRhdGVzLCBtYXgpKTsKK30KKwordm9pZCBDQ1RocmVhZFByb3h5OjpzZXRNYXhQ YXJ0aWFsVGV4dHVyZVVwZGF0ZXMoc2l6ZV90IG1heCkKK3sKKyAgICBBU1NFUlQoaXNNYWluVGhy ZWFkKCkpOworICAgIG1fbWF4UGFydGlhbFRleHR1cmVVcGRhdGVzID0gbWF4OworfQorCiB2b2lk IENDVGhyZWFkUHJveHk6OmluaXRpYWxpemVJbXBsT25JbXBsVGhyZWFkKENDQ29tcGxldGlvbkV2 ZW50KiBjb21wbGV0aW9uKQogewogICAgIFRSQUNFX0VWRU5UMCgiY2MiLCAiQ0NUaHJlYWRQcm94 eTo6aW5pdGlhbGl6ZUltcGxPbkltcGxUaHJlYWQiKTsKQEAgLTkxNyw3ICs5MjksNyBAQCB2b2lk IENDVGhyZWFkUHJveHk6OnNldEZ1bGxSb290TGF5ZXJEYW1hZ2VPbkltcGxUaHJlYWQoKQogCiBz aXplX3QgQ0NUaHJlYWRQcm94eTo6bWF4UGFydGlhbFRleHR1cmVVcGRhdGVzKCkgY29uc3QKIHsK LSAgICByZXR1cm4gQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlcjo6bWF4UGFydGlhbFRleHR1cmVV cGRhdGVzKCk7CisgICAgcmV0dXJuIG1fbWF4UGFydGlhbFRleHR1cmVVcGRhdGVzOwogfQogCiB2 b2lkIENDVGhyZWFkUHJveHk6OnJlY3JlYXRlQ29udGV4dE9uSW1wbFRocmVhZChDQ0NvbXBsZXRp b25FdmVudCogY29tcGxldGlvbiwgQ0NHcmFwaGljc0NvbnRleHQqIGNvbnRleHRQdHIsIGJvb2wq IHJlY3JlYXRlU3VjY2VlZGVkLCBSZW5kZXJlckNhcGFiaWxpdGllcyogY2FwYWJpbGl0aWVzKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NUaHJlYWRQcm94eS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vY2MvQ0NUaHJlYWRQcm94eS5oCmluZGV4IGM0OGRmOTMwNTk5NmJjNDAzZjY2ZWM1Y2Q5YTNl OWIzNmM2NWRlZDcuLjU4YTNkMzJkOGZiZTRkNzZhZjQ5MTk4ZDRhZTgwNmRiNDcyNTk5NTAgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND VGhyZWFkUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9jYy9DQ1RocmVhZFByb3h5LmgKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlICJDQ0xh eWVyVHJlZUhvc3RJbXBsLmgiCiAjaW5jbHVkZSAiQ0NQcm94eS5oIgogI2luY2x1ZGUgIkNDU2No ZWR1bGVyLmgiCisjaW5jbHVkZSAiQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlci5oIgogI2luY2x1 ZGUgPHd0Zi9Pd25QdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtMzksMTEgKzQwLDEw IEBAIGNsYXNzIENDTGF5ZXJUcmVlSG9zdDsKIGNsYXNzIENDU2NoZWR1bGVyOwogY2xhc3MgQ0NT Y29wZWRUaHJlYWRQcm94eTsKIGNsYXNzIENDVGV4dHVyZVVwZGF0ZVF1ZXVlOwotY2xhc3MgQ0NU ZXh0dXJlVXBkYXRlQ29udHJvbGxlcjsKIGNsYXNzIENDVGhyZWFkOwogY2xhc3MgQ0NUaHJlYWRQ cm94eUNvbnRleHRSZWNyZWF0aW9uVGltZXI7CiAKLWNsYXNzIENDVGhyZWFkUHJveHkgOiBwdWJs aWMgQ0NQcm94eSwgQ0NMYXllclRyZWVIb3N0SW1wbENsaWVudCwgQ0NTY2hlZHVsZXJDbGllbnQg eworY2xhc3MgQ0NUaHJlYWRQcm94eSA6IHB1YmxpYyBDQ1Byb3h5LCBDQ0xheWVyVHJlZUhvc3RJ bXBsQ2xpZW50LCBDQ1NjaGVkdWxlckNsaWVudCwgQ0NUZXh0dXJlVXBkYXRlQ29udHJvbGxlckNs aWVudCB7CiBwdWJsaWM6CiAgICAgc3RhdGljIFBhc3NPd25QdHI8Q0NQcm94eT4gY3JlYXRlKEND TGF5ZXJUcmVlSG9zdCopOwogCkBAIC05NCw2ICs5NCw5IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFs IHZvaWQgc2NoZWR1bGVkQWN0aW9uQmVnaW5Db250ZXh0UmVjcmVhdGlvbigpIE9WRVJSSURFOwog ICAgIHZpcnR1YWwgdm9pZCBzY2hlZHVsZWRBY3Rpb25BY3F1aXJlTGF5ZXJUZXh0dXJlc0Zvck1h aW5UaHJlYWQoKSBPVkVSUklERTsKIAorICAgIC8vIENDVGV4dHVyZVVwZGF0ZUNvbnRyb2xsZXJD bGllbnQKKyAgICB2aXJ0dWFsIHZvaWQgc2V0TWF4UGFydGlhbFRleHR1cmVVcGRhdGVzT25JbXBs VGhyZWFkKHNpemVfdCkgT1ZFUlJJREU7CisKIHByaXZhdGU6CiAgICAgZXhwbGljaXQgQ0NUaHJl YWRQcm94eShDQ0xheWVyVHJlZUhvc3QqKTsKICAgICBmcmllbmQgY2xhc3MgQ0NUaHJlYWRQcm94 eUNvbnRleHRSZWNyZWF0aW9uVGltZXI7CkBAIC0xMTksNiArMTIyLDcgQEAgcHJpdmF0ZToKICAg ICB2b2lkIHNldEFuaW1hdGlvbkV2ZW50cyhQYXNzT3duUHRyPENDQW5pbWF0aW9uRXZlbnRzVmVj dG9yPiwgZG91YmxlIHdhbGxDbG9ja1RpbWUpOwogICAgIHZvaWQgYmVnaW5Db250ZXh0UmVjcmVh dGlvbigpOwogICAgIHZvaWQgdHJ5VG9SZWNyZWF0ZUNvbnRleHQoKTsKKyAgICB2b2lkIHNldE1h eFBhcnRpYWxUZXh0dXJlVXBkYXRlcyhzaXplX3QpOwogCiAgICAgLy8gQ2FsbGVkIG9uIGltcGwg dGhyZWFkCiAgICAgc3RydWN0IFJlYWRiYWNrUmVxdWVzdCB7CkBAIC0xNjAsNiArMTY0LDcgQEAg cHJpdmF0ZToKICAgICBib29sIG1fc3RhcnRlZDsKICAgICBib29sIG1fdGV4dHVyZXNBY3F1aXJl ZDsKICAgICBib29sIG1faW5Db21wb3NpdGVBbmRSZWFkYmFjazsKKyAgICBzaXplX3QgbV9tYXhQ YXJ0aWFsVGV4dHVyZVVwZGF0ZXM7CiAKICAgICBPd25QdHI8Q0NMYXllclRyZWVIb3N0SW1wbD4g bV9sYXllclRyZWVIb3N0SW1wbDsKIAo=