203557 2019-10-29 02:25:30 -0700 Determine viewport distances for lazy image loading 2021-10-13 22:29:30 -0700 1 1 1 Unclassified WebKit Images Other Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 196698 200764 208094 1 rbuis rbuis addyo bjr.roberts bugmail caezaris cdumez changseok darin domfarolino emilio esprehn+autocc ews-watchlist fjeldsoe gsnedders gyuyoung.kim japhet jonlee kangil.han kondapallykalyan mjs nikolay.latyshev nmouchtaris pp.mizdra sergio simon.fraser zcorpan oldest_to_newest 1584862 0 rbuis 2019-10-29 02:25:30 -0700 Determine viewport distances for lazy image loading for desktop, iOS etc. 1584863 1 382169 rbuis 2019-10-29 02:28:58 -0700 Created attachment 382169 Patch 1621891 2 mjs 2020-02-22 12:26:23 -0800 Why is the viewport distance different for iOS than everything else? I think the same behavior is reasonably appropriate for all platforms. If anything it should be a function of how fast it's possible to scroll on that platform. 1621894 3 mjs 2020-02-22 12:29:54 -0800 Also curious, where does 100px come from? Is that the threshold Chrome uses? 1621896 4 mjs 2020-02-22 12:37:57 -0800 According to this article, Chromium uses significantly higher distances <https://www.ctrl.blog/entry/lazy-loading-viewports.html> > Chromium/Blink uses a margin of 3000px on low-latency network connections, and up to 8000px on high-latency connections. This seems like a reasonable starting point, though it might need some kind of input on expected network latency from the network stack. I could also imagine wanting a different threshold in some sort of "save data" mode, but I'm not sure WebKit has that as a concept yet. If the threshold is lower for smaller screens, it should probably be based on viewport height, not OS. iPads should probably have a threshold similar to desktop devices at the same viewport height, for instance. 1622065 5 rbuis 2020-02-24 00:19:35 -0800 (In reply to Maciej Stachowiak from comment #3) > Also curious, where does 100px come from? Is that the threshold Chrome uses? I can't find any reference to that except the patch attached to this bug. 1622089 6 391519 rbuis 2020-02-24 02:11:31 -0800 Created attachment 391519 Patch 1627740 7 rbuis 2020-03-09 07:35:40 -0700 (In reply to Maciej Stachowiak from comment #2) > Why is the viewport distance different for iOS than everything else? I think > the same behavior is reasonably appropriate for all platforms. If anything > it should be a function of how fast it's possible to scroll on that platform. Using scrolling speed does sound reasonable to me. 1627744 8 rbuis 2020-03-09 07:39:10 -0700 (In reply to Maciej Stachowiak from comment #3) > Also curious, where does 100px come from? Is that the threshold Chrome uses? For the record, right now we should match Firefox in that we simply do not use a threshold value. From my tests on desktop and with my reasonable internet connection this works well, but things may be different on mobile and so-so connections. 1627823 9 simon.fraser 2020-03-09 10:08:04 -0700 (In reply to Rob Buis from comment #7) > (In reply to Maciej Stachowiak from comment #2) > > Why is the viewport distance different for iOS than everything else? I think > > the same behavior is reasonably appropriate for all platforms. If anything > > it should be a function of how fast it's possible to scroll on that platform. > > Using scrolling speed does sound reasonable to me. We already have scrolling speed computations for tile coverage (see GraphicsLayerCA::adjustCoverageRect()). This stuff is hard to get right, and I'd be reluctant to see another implementation added. I'd prefer to leverage existing IntersectionObserver or tile coverage code. 1628276 10 rbuis 2020-03-10 09:22:21 -0700 (In reply to Simon Fraser (smfr) from comment #9) > (In reply to Rob Buis from comment #7) > > (In reply to Maciej Stachowiak from comment #2) > > > Why is the viewport distance different for iOS than everything else? I think > > > the same behavior is reasonably appropriate for all platforms. If anything > > > it should be a function of how fast it's possible to scroll on that platform. > > > > Using scrolling speed does sound reasonable to me. > > We already have scrolling speed computations for tile coverage (see > GraphicsLayerCA::adjustCoverageRect()). This stuff is hard to get right, and > I'd be reluctant to see another implementation added. I'd prefer to leverage > existing IntersectionObserver or tile coverage code. I played around with it today. On my 15" mbp I get values for roughly the window height (I use mini browser) when I add logging. However it seems at LazyLoadImageObserver construction time the information is not reliable yet, I guess because compositing has not been done/started yet? Exposing some GraphicsLayer API is easy for me but it is harder for me to reason about compositing which I am not familiar with. Is an alternative to use heuristics approximating it? 1629629 11 rbuis 2020-03-13 09:05:43 -0700 I looked at this a bit more, I think there is a problem with using GraphicsLayerCA::adjustCoverageRect(). In RemoteLayerTreeDrawingArea::updateRendering(), m_webPage.updateRendering() is called first, which will run the intersection observer algorithm. However GraphicsLayerCA::adjustCoverageRect() is only called a bit later using m_webPage.mainFrameView()>flushCompositingStateIncludingSubframes(). So AFAICS the intersection observer algorithm could use the coverage rect information from the previous time RemoteLayerTreeDrawingArea::updateRendering was called, but not the current time. 1630372 12 simon.fraser 2020-03-16 10:43:42 -0700 (In reply to Rob Buis from comment #11) > I looked at this a bit more, I think there is a problem with using > GraphicsLayerCA::adjustCoverageRect(). > > In RemoteLayerTreeDrawingArea::updateRendering(), > m_webPage.updateRendering() is called first, which will run the intersection > observer algorithm. > > However GraphicsLayerCA::adjustCoverageRect() is only called a bit later > using m_webPage.mainFrameView()>flushCompositingStateIncludingSubframes(). > > So AFAICS the intersection observer algorithm could use the coverage rect > information from the previous time > RemoteLayerTreeDrawingArea::updateRendering was called, but not the current > time. That's true. 1630768 13 393764 rbuis 2020-03-17 10:11:33 -0700 Created attachment 393764 Patch 1631364 14 rbuis 2020-03-18 14:38:34 -0700 (In reply to Simon Fraser (smfr) from comment #12) > (In reply to Rob Buis from comment #11) > > So AFAICS the intersection observer algorithm could use the coverage rect > > information from the previous time > > RemoteLayerTreeDrawingArea::updateRendering was called, but not the current > > time. > > That's true. Simon, is the m_coverageRect in document coordinates? And if not how can it be converted? 1636411 15 395139 rbuis 2020-04-01 00:41:33 -0700 Created attachment 395139 Patch 1636425 16 395148 rbuis 2020-04-01 01:40:53 -0700 Created attachment 395148 Patch 1636466 17 395161 rbuis 2020-04-01 06:58:15 -0700 Created attachment 395161 Patch 1636510 18 395171 rbuis 2020-04-01 08:54:37 -0700 Created attachment 395171 Patch 1636596 19 395171 simon.fraser 2020-04-01 12:03:41 -0700 Comment on attachment 395171 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395171&action=review > Source/WebCore/dom/Document.cpp:7570 > + if (observer.determineDynamicRootMargin()) { "dynamic" is a bit vague. Maybe paintCoverageRootMargin? > Source/WebCore/page/FrameView.cpp:5453 > +FloatRect FrameView::coverageRect() const Is it OK that this will lag one frame behind? Does something trigger a rendering update if coverage rect changes in a frame, but there are no other changes that trigger one? 1637505 20 395407 rbuis 2020-04-03 13:12:49 -0700 Created attachment 395407 Patch 1637507 21 395171 rbuis 2020-04-03 13:17:04 -0700 Comment on attachment 395171 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395171&action=review >> Source/WebCore/dom/Document.cpp:7570 >> + if (observer.determineDynamicRootMargin()) { > > "dynamic" is a bit vague. Maybe paintCoverageRootMargin? Sure, I used that name now. >> Source/WebCore/page/FrameView.cpp:5453 >> +FloatRect FrameView::coverageRect() const > > Is it OK that this will lag one frame behind? > > Does something trigger a rendering update if coverage rect changes in a frame, but there are no other changes that trigger one? The first frame there will not be any coverage rect but I think the fallback to viewport height is reasonable. Later frames will indeed lag one frame behind but from my testing on OS X the coverage rect height is pretty constant while scrolling, so I don't think it is a problem. Can you detail your second question or give an example? I am not familiar with compositing and only a bit with rendering (these days). 1637509 22 395407 darin 2020-04-03 13:23:05 -0700 Comment on attachment 395407 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395407&action=review > Source/WebCore/dom/Document.cpp:7580 > + auto intRect = enclosingIntRect(floatRect); I suggest only putting the height into a local variable since we aren’t using the location or width: auto height = enclosingIntRect(floatRect).height(); > Source/WebCore/dom/Document.cpp:7581 > + fprintf(stderr, "Using rect %d\n", intRect.height()); I suspect this printf is something you do not want to check in? > Source/WebCore/html/LazyLoadImageObserver.cpp:80 > auto& observer = document.lazyLoadImageObserver(); > - ASSERT(observer.isObserved(element)); > observer.m_lazyLoadIntersectionObserver->unobserve(element); I suggest making it a one-liner. > Source/WebCore/page/FrameView.cpp:5481 > + RenderView* renderView = this->renderView(); > + if (!renderView) > + return FloatRect(); > + > + RenderLayerBacking* backing = renderView->layer()->backing(); > + if (!backing) > + return FloatRect(); > + > + auto* graphicsLayer = backing->graphicsLayer(); > + if (!graphicsLayer) > + return FloatRect(); > + > + return graphicsLayer->coverageRect(); My preference is just "auto" here for all these locals, and one word names. Local variable names like "view", "backing", "layer" don’t need to be two word phrases in such a short function; the type system will make sure we don’t get it wrong. Also like { } better than FloatRect(). auto view = renderView(); if (!view) return { }; Maybe the word "view" isn’t so good? An advantage of auto is that if we change to return RefPtr we don’t have to change call sites like these. If we wrote "auto*" then we would. It’s better not to be so specific; we want to null check something and dereference it, but we don’t need to constrain its type. > Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h:326 > + FloatRect coverageRect() const override { return m_coverageRect; } Can this be final instead? 1637536 23 simon.fraser 2020-04-03 15:02:51 -0700 Should we land this before https://github.com/whatwg/html/issues/5408 is resolved? 1638222 24 395597 rbuis 2020-04-06 12:06:33 -0700 Created attachment 395597 Patch 1638290 25 395407 rbuis 2020-04-06 13:40:36 -0700 Comment on attachment 395407 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=395407&action=review >> Source/WebCore/dom/Document.cpp:7580 >> + auto intRect = enclosingIntRect(floatRect); > > I suggest only putting the height into a local variable since we aren’t using the location or width: > > auto height = enclosingIntRect(floatRect).height(); Sure, done. >> Source/WebCore/dom/Document.cpp:7581 >> + fprintf(stderr, "Using rect %d\n", intRect.height()); > > I suspect this printf is something you do not want to check in? Oops! Removed. >> Source/WebCore/html/LazyLoadImageObserver.cpp:80 >> observer.m_lazyLoadIntersectionObserver->unobserve(element); > > I suggest making it a one-liner. Done. >> Source/WebCore/page/FrameView.cpp:5481 >> + return graphicsLayer->coverageRect(); > > My preference is just "auto" here for all these locals, and one word names. Local variable names like "view", "backing", "layer" don’t need to be two word phrases in such a short function; the type system will make sure we don’t get it wrong. Also like { } better than FloatRect(). > > auto view = renderView(); > if (!view) > return { }; > > Maybe the word "view" isn’t so good? > > An advantage of auto is that if we change to return RefPtr we don’t have to change call sites like these. If we wrote "auto*" then we would. It’s better not to be so specific; we want to null check something and dereference it, but we don’t need to constrain its type. Done. Yes I am starting to see the benefits of auto. >> Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h:326 >> + FloatRect coverageRect() const override { return m_coverageRect; } > > Can this be final instead? Sure, done. 1638313 26 rbuis 2020-04-06 14:24:54 -0700 (In reply to Simon Fraser (smfr) from comment #23) > Should we land this before https://github.com/whatwg/html/issues/5408 is > resolved? The expectation is that nothing stronger than a recommendation/hint will be the result. But it looks like Simon Pieters is actively investigating so indeed we can hold landing this off maybe a bit longer. Related to that, are there any APIs available to me to take into account connection speed/battery life? Any existing code in WebKit that queries this information? 1638338 27 simon.fraser 2020-04-06 15:06:02 -0700 (In reply to Rob Buis from comment #26) > there any APIs available to me to take into account connection speed/battery > life? Any existing code in WebKit that queries this information? No, because we consider those privacy-sensitive. 1644947 28 395597 rbuis 2020-04-23 13:37:20 -0700 Comment on attachment 395597 Patch I am disabling cq for this patch based on Simon's comment in https://github.com/whatwg/html/issues/5408, to avoid any confusion about the state of the patch. Simon, any suggestions what we could try instead, or should we wait 5408 discussion? 1688690 29 zcorpan 2020-09-15 08:09:46 -0700 If you were waiting on https://github.com/whatwg/html/issues/5408 , I've now written a PR at https://github.com/whatwg/html/pull/5917 1700853 30 zcorpan 2020-10-22 15:00:35 -0700 https://github.com/whatwg/html/pull/5917 has now been merged. See https://github.com/whatwg/html/issues/5408#issuecomment-643505639 for what Chromium is currently doing. The relevant distances are in https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/core/frame/settings.json5 (e.g. "lazyImageLoadingDistanceThresholdPx4G"). 1738506 31 rbuis 2021-03-11 10:01:10 -0800 Is there a new approach I can experiment with? Latest change Mozilla made for this feature seems to be https://bugzilla.mozilla.org/show_bug.cgi?id=1673785. 1738527 32 simon.fraser 2021-03-11 10:49:35 -0800 300px seems way too small. Chrome's 1250px seems more reasonable for macOS/iOS scrolling speeds. I think we should implement something in the 1000px range (or some multiple of viewport size) and play with it. 1739465 33 423186 rbuis 2021-03-15 09:08:25 -0700 Created attachment 423186 Patch 1739497 34 423186 darin 2021-03-15 10:05:51 -0700 Comment on attachment 423186 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=423186&action=review > Source/WebCore/html/LazyLoadImageObserver.cpp:90 > + if (auto renderView = document.renderView()) { > + StringBuilder builder; > + builder.appendNumber(renderView->viewportSizeForCSSViewportUnits().height()); > + builder.append("px 0px"); > + return builder.toString(); > + } This should use makeString instead of StringBuilder. It’s more efficient and reads better too: if (auto renderView = document.renderView()) return makeString(renderView->viewportSizeForCSSViewportUnits().height(), "px 0px"); 1739525 35 423199 rbuis 2021-03-15 10:50:49 -0700 Created attachment 423199 Patch 1739583 36 423199 darin 2021-03-15 12:26:15 -0700 Comment on attachment 423199 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=423199&action=review > Source/WebCore/html/LazyLoadImageObserver.cpp:88 > + if (auto renderView = document.renderView()) > + return makeString(renderView->viewportSizeForCSSViewportUnits().height(), "px 0px"); > + static NeverDestroyed<const String> lazyLoadingRootMarginFallback(MAKE_STATIC_STRING_IMPL("1250px 0px")); > + return lazyLoadingRootMarginFallback; Had three other follow-up thoughts: 1) Just realized that this accesses the RenderView without doing any form of "updateLayout" first. Not sure that’s OK. 2) Should probably write it like this: auto renderView = document.renderView(); return makeString(renderView ? renderView->viewportSizeForCSSViewportUnits().height() : 1250, "px 0px"); Why go to the trouble of optimizing the very unusual case where there is no RenderView? Might want the 1250 to be a named constant, also, so we can comment and explain how we chose the value. 3) Side note about MAKE_STATIC_STRING_IMPL: If we do keep around a string constant, we should figure out if MAKE_STATIC_STRING_IMPL is optimizing for the right thing in this case. I’d be tempted to just write this: return "1250px 0px"_s; That allocates a String every time this is called, but points at the characters in the binary rather than copying them into the WTF::StringImpl object; it’s pretty efficient and the smallest, I think, although the thing above in (2) is even smaller. The next level of optimization is to eliminate the cost of creating and destroying a string every time by doing this (not sure I have the syntax right): static NeverDestroyed<String> fallback = "1250px 0px"_s return fallback; That uses a single global string so it’s never destroyed. The next level would be to use ConstructFromLiteral, slightly more efficient to initialize because it doesn't compute the length at runtime, but uglier source code and generates a slightly bigger binary since it compiles the length in. MAKE_STATIC_STRING_IMPL is a further optimization that we devised, specifically because we wanted a thread safe way to do it I think. It’s definitely uglier in its own way (ALL CAPS) and also seems to trade off an even bigger binary for slightly better performance. I don’t think we want to use MAKE_STATIC_STRING_IMPL any time we want to return a constant string value. I’d love to find a rule of thumb. 1763003 37 addyo 2021-05-23 20:18:38 -0700 Sharing some insight from Chrome's experiments into LazyLoad thresholds in case it may be helpful for WebKit: - We experimented with a number of popular JavaScript library solutions for lazy-loading and determined that the optimal threshold (for specifically aligning with developer expectations) is in the range of 750px - 1250px for the root-margin. When testing values in this range manually, they also appeared to meet user expectations of a good experience during scroll. - We studied (at scale) how developers would manually override threshold values when using a library like LazySizes. The most common override value was ~1000px. Some would set it higher and others slightly lower, but not by a large amount. - I agree with Simon that 300px as a threshold is too small. I would recommend 1250px as the feedback from developers has been this met most expectations. I could also see the argument for a value in the 1000-1250px range (given the above note). I do think it's worth experimenting. - With respect to https://github.com/w3c/IntersectionObserver/issues/431, Google properties are a bit behind in terms of switching to native LazyLoad for their carousels and I unfortunately haven't received any notes regarding shortcomings from those who have updated to use loading=lazy. That said, I view 431 as a nice incremental addition to LazyLoad that could come later. I hope something in here is helpful to the discussion... :) 1776459 38 gsnedders 2021-07-12 14:39:18 -0700 (In reply to Darin Adler from comment #36) > Might want the 1250 to be a named constant, also, so we can > comment and explain how we chose the value. I do wonder if it makes sense to make it a setting, rather than hardcoding the value into WebCore. This would also make experimenting easier, and non-web applications might have their own opinions here. 1783915 39 bjr.roberts 2021-08-12 12:25:04 -0700 I've been advocating that expressing these thresholds in vh/vw is superior to static px values. Hasn't gotten much traction on chromium yet. https://bugs.chromium.org/p/chromium/issues/detail?id=1011182 1786875 40 zcorpan 2021-08-24 12:11:10 -0700 Hi folks, This issue was discussed on Twitter last week: https://twitter.com/zcorpan/status/1427878342531948545 While implementing the non-normative suggestions in the spec in a good way will require some testing and research, I suggest that a simple approach like a fixed pixel value is good enough for a first version. 1786878 41 simon.fraser 2021-08-24 12:12:42 -0700 Twitter also noted that Chrome had a bug with printing. We need a story for printing and lazy image loads. 1791998 42 domfarolino 2021-09-09 11:11:27 -0700 It seems like Firefox handles this correctly if I understand Emilio's comment [1] correctly. A good start would be for someone to spec what should happen here. That would certainly go towards unblocking our Chromium bug around this as well, and would probably up the priority of it. (Unfortunately we're not staffing any effort around that bug and other lingering lazyload issues at the moment). [1]: https://github.com/whatwg/html/issues/6581#issuecomment-821910632 [2]: https://bugs.chromium.org/p/chromium/issues/detail?id=875403 1798848 43 439729 rbuis 2021-09-30 06:11:51 -0700 Created attachment 439729 Patch 1798916 44 rbuis 2021-09-30 10:06:17 -0700 (In reply to Ben Roberts from comment #39) > I've been advocating that expressing these thresholds in vh/vw is superior > to static px values. Hasn't gotten much traction on chromium yet. > https://bugs.chromium.org/p/chromium/issues/detail?id=1011182 I also like that idea since some time. I made a new patch that basically uses 1vh above and below the current page for the areas to start lazy image loads. 1798926 45 439729 simon.fraser 2021-09-30 10:17:32 -0700 Comment on attachment 439729 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=439729&action=review > Source/WebCore/html/LazyLoadImageObserver.cpp:89 > + static NeverDestroyed<const String> lazyLoadingRootMarginFallback(MAKE_STATIC_STRING_IMPL("100% 0px")); > + IntersectionObserver::Init options { std::nullopt, lazyLoadingRootMarginFallback, { } }; Doesn't this need to account for horizontally scrollable documents? You need to look at main view scrollability. 1799025 46 zcorpan 2021-09-30 14:14:48 -0700 Can you use "1 viewport in all directions"? 1799449 47 439891 rbuis 2021-10-01 12:00:50 -0700 Created attachment 439891 Patch 1800191 48 rbuis 2021-10-04 13:05:39 -0700 (In reply to Simon Pieters (:zcorpan) from comment #46) > Can you use "1 viewport in all directions"? I think so, I tried to implement that in my latest patch. 1800218 49 simon.fraser 2021-10-04 14:12:03 -0700 Is it OK to load images offscreen on an axis that that the user can never scroll to? Should images that can only be revealed by rubber-banding lazy-load? 1800770 50 rbuis 2021-10-05 14:34:27 -0700 (In reply to Simon Fraser (smfr) from comment #49) > Is it OK to load images offscreen on an axis that that the user can never > scroll to? You mean load lazily? Seems ok if the web author wants to do that for some reason. Also note that AFAICS the offscreen image can be moved into viewport by repositioning/JS, so I am not sure we can make any assumptions about images being offscreen at a certain moment. > Should images that can only be revealed by rubber-banding lazy-load? I do not see the problem, using a suitable root margin liken the patch they would be revealed like they are eagerly loaded AFAICS. 1800776 51 simon.fraser 2021-10-05 14:43:33 -0700 (In reply to Rob Buis from comment #50) > (In reply to Simon Fraser (smfr) from comment #49) > > Is it OK to load images offscreen on an axis that that the user can never > > scroll to? > > You mean load lazily? Seems ok if the web author wants to do that for some > reason. Also note that AFAICS the offscreen image can be moved into viewport > by repositioning/JS, so I am not sure we can make any assumptions about > images being offscreen at a certain moment. I'm thinking of a case where a page as a bunch of lazy-load images stacked just offscreen (left: -100%) because the author wants to animated them in. A default horizontal root margin of 100vw (on a page that is not horizontally scrollble) will trigger loads on these images when the author may not expect that, because the user can't reveal these images via scrolling. Also, how does lazy loading and animation interact? If an image is brought into the lazy-loading area via a transform animation, does it load? This needs a bunch of WPT testing. 1801101 52 rbuis 2021-10-06 08:44:16 -0700 (In reply to Simon Fraser (smfr) from comment #51) > Also, how does lazy loading and animation interact? If an image is brought > into the lazy-loading area via a transform animation, does it load? This relies on intersection observer. Intersection observer seems to trigger the callback but only once the animation ends: https://jsfiddle.net/38v2dots/2/ Firefox triggers as soon as the image enters the viewport. Not sure what the specification says about this but to me Firefox behaviour seems more intuitive. 1801114 53 gsnedders 2021-10-06 08:57:01 -0700 (In reply to Simon Fraser (smfr) from comment #51) > This needs a bunch of WPT testing. Some of the tests in https://wpt.fyi/results/html/semantics/embedded-content/the-img-element?label=master&label=experimental&product=chrome&product=firefox&product=webkitgtk&aligned&q=lazy seem to be related to such things (image-loading-lazy-negative-margin.html for one). 1801128 54 rbuis 2021-10-06 09:18:19 -0700 (In reply to Sam Sneddon [:gsnedders] from comment #53) > (In reply to Simon Fraser (smfr) from comment #51) > > This needs a bunch of WPT testing. > > Some of the tests in > https://wpt.fyi/results/html/semantics/embedded-content/the-img- > element?label=master&label=experimental&product=chrome&product=firefox&produc > t=webkitgtk&aligned&q=lazy seem to be related to such things > (image-loading-lazy-negative-margin.html for one). Well spotted, importing them here: https://bugs.webkit.org/show_bug.cgi?id=231297 1802855 55 jonlee 2021-10-11 15:51:19 -0700 What's next here? Do we need to resubmit the patch to check what EWS says? 1803307 56 rbuis 2021-10-12 12:30:05 -0700 (In reply to Simon Fraser (smfr) from comment #51) > (In reply to Rob Buis from comment #50) > > (In reply to Simon Fraser (smfr) from comment #49) > > > Is it OK to load images offscreen on an axis that that the user can never > > > scroll to? > > > > You mean load lazily? Seems ok if the web author wants to do that for some > > reason. Also note that AFAICS the offscreen image can be moved into viewport > > by repositioning/JS, so I am not sure we can make any assumptions about > > images being offscreen at a certain moment. > > I'm thinking of a case where a page as a bunch of lazy-load images stacked > just offscreen (left: -100%) because the author wants to animated them in. A > default horizontal root margin of 100vw (on a page that is not horizontally > scrollble) will trigger loads on these images when the author may not expect > that, because the user can't reveal these images via scrolling. Are you willing to create a GitHub issue for this? I mostly get what you are saying but I think you can formulate it better than I could. > Also, how does lazy loading and animation interact? If an image is brought > into the lazy-loading area via a transform animation, does it load? I created https://github.com/w3c/IntersectionObserver/issues/484 for this. 1803309 57 rbuis 2021-10-12 12:31:11 -0700 (In reply to Jon Lee from comment #55) > What's next here? Do we need to resubmit the patch to check what EWS says? Simon still has some questions so likely we will have to get clarification on spec level and maybe add some WPT tests. 1803933 58 gsnedders 2021-10-13 13:17:40 -0700 (In reply to Rob Buis from comment #57) > (In reply to Jon Lee from comment #55) > > What's next here? Do we need to resubmit the patch to check what EWS says? > > Simon still has some questions so likely we will have to get clarification > on spec level and maybe add some WPT tests. Should we review/land this, even if we keep it behind the flag for now? Get it to the point where it's more easily testable. 1804163 59 ews-feeder 2021-10-13 22:29:24 -0700 Committed r284148 (242968@main): <https://commits.webkit.org/242968@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 439891. 382169 2019-10-29 02:28:58 -0700 2020-02-24 02:11:27 -0800 Patch bug-203557-20191029102856.patch text/plain 2115 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjUxNjkzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWJhM2ExZDdiMWQyZTFk MzFlODJmZTAyMTYzZjYyNDAwZWNmZGM2NS4uMTFlYTZiMzQ2N2I5ZTUzYmNiMTg3MGI3NzgxODgx NDMwOTg2YTFmOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDE5LTEwLTI5ICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBEZXRlcm1pbmUgYXBwcm9wcmlhdGUgbGF6eSBpbWFnZSBs b2FkaW5nIHZpZXdwb3J0IGRpc3RhbmNlcyAKKyAgICAgICAgZm9yIGRlc2t0b3AgYW5kIG1vYmls ZSBkZXZpY2VzLgorCisgICAgICAgICogaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6dmlld3BvcnREaXN0YW5jZVRocmVzaG9sZCk6CisgICAgICAgIChX ZWJDb3JlOjpMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6OmludGVyc2VjdGlvbk9ic2VydmVyKToKKwog MjAxOS0xMC0yOCAgWXVzdWtlIFN1enVraSAgPHlzdXp1a2lAYXBwbGUuY29tPgogCiAgICAgICAg IFtKU0NdIFJlbW92ZSBKU1Byb21pc2VEZWZlcnJlZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9M YXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwCmluZGV4IDhlODllY2QyNjA5OTNlNzczYjE0NTMwN2Vl MGZkNzY0YjM4NmNjZWQuLmI3Zjg0NDI3OTIxZWVhYTBkMWYyYjE3MDU3NTEyMTJhMTJmNjAxNTYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHAKQEAg LTgxLDExICs4MSwyMSBAQCB2b2lkIExhenlMb2FkSW1hZ2VPYnNlcnZlcjo6dW5vYnNlcnZlKEVs ZW1lbnQmIGVsZW1lbnQpCiAgICAgb2JzZXJ2ZXIubV9sYXp5TG9hZEludGVyc2VjdGlvbk9ic2Vy dmVyLT51bm9ic2VydmUoZWxlbWVudCk7CiB9CiAKK3N0YXRpYyBTdHJpbmcgdmlld3BvcnREaXN0 YW5jZVRocmVzaG9sZCgpCit7CisjaWYgUExBVEZPUk0oSU9TX0ZBTUlMWSkKKyAgICByZXR1cm4g ZW1wdHlTdHJpbmcoKTsKKyNlbHNlCisgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPGNvbnN0IFN0 cmluZz4gZGVza3RvcFZpZXdwb3J0RGlzdGFuY2UoTUFLRV9TVEFUSUNfU1RSSU5HX0lNUEwoIjEw MHB4IDBweCIpKTsKKyAgICByZXR1cm4gZGVza3RvcFZpZXdwb3J0RGlzdGFuY2U7CisjZW5kaWYK K30KKwogSW50ZXJzZWN0aW9uT2JzZXJ2ZXIqIExhenlMb2FkSW1hZ2VPYnNlcnZlcjo6aW50ZXJz ZWN0aW9uT2JzZXJ2ZXIoRG9jdW1lbnQmIGRvY3VtZW50KQogewogICAgIGlmICghbV9sYXp5TG9h ZEludGVyc2VjdGlvbk9ic2VydmVyKSB7CiAgICAgICAgIGF1dG8gY2FsbGJhY2sgPSBMYXp5SW1h Z2VMb2FkSW50ZXJzZWN0aW9uT2JzZXJ2ZXJDYWxsYmFjazo6Y3JlYXRlKGRvY3VtZW50KTsKLSAg ICAgICAgYXV0byBvcHRpb25zID0gSW50ZXJzZWN0aW9uT2JzZXJ2ZXI6OkluaXQgeyBudWxscHRy LCBlbXB0eVN0cmluZygpLCB7IH0gfTsKKyAgICAgICAgYXV0byBvcHRpb25zID0gSW50ZXJzZWN0 aW9uT2JzZXJ2ZXI6OkluaXQgeyBudWxscHRyLCB2aWV3cG9ydERpc3RhbmNlVGhyZXNob2xkKCks IHsgfSB9OwogICAgICAgICBhdXRvIG9ic2VydmVyID0gSW50ZXJzZWN0aW9uT2JzZXJ2ZXI6OmNy ZWF0ZShkb2N1bWVudCwgV1RGTW92ZShjYWxsYmFjayksIFdURk1vdmUob3B0aW9ucykpOwogICAg ICAgICBpZiAob2JzZXJ2ZXIuaGFzRXhjZXB0aW9uKCkpCiAgICAgICAgICAgICByZXR1cm4gbnVs bHB0cjsK 391519 2020-02-24 02:11:31 -0800 2020-03-17 10:11:29 -0700 Patch bug-203557-20200224111130.patch text/plain 2131 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3MjAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWI4YzVkZTM5NzQ1MTMz YmM4NmU1NWM4MWM3MDcxZjk0ODVhOGUyNi4uNTc3NzQxZjVjMWJkMDYyNmFkNjc5YzIwMGJjMDg1 YjI2M2IwZjhhNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIwLTAyLTI0ICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBEZXRlcm1pbmUgYXBwcm9wcmlhdGUgbGF6eSBpbWFnZSBs b2FkaW5nIHZpZXdwb3J0IGRpc3RhbmNlcworICAgICAgICBmb3IgZGVza3RvcCBhbmQgbW9iaWxl IGRldmljZXMuCisKKyAgICAgICAgKiBodG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjp2aWV3cG9ydERpc3RhbmNlVGhyZXNob2xkKToKKyAgICAgICAgKFdl YkNvcmU6OkxhenlMb2FkSW1hZ2VPYnNlcnZlcjo6aW50ZXJzZWN0aW9uT2JzZXJ2ZXIpOgorCiAy MDIwLTAyLTIzICBBbmRyZXMgR29uemFsZXogIDxhbmRyZXNnXzIyQGFwcGxlLmNvbT4KIAogICAg ICAgICBBWElzb2xhdGVkT2JqZWN0IHN1cHBvcnQgZm9yIHRhYmxlcy4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcCBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcAppbmRleCBmNDA4NDA5YjY4NDQyNTI0 M2M2ODRkOTlhNDljZTBhYTIyYmNhOTc4Li5lZDM2YmI4MGFhZjQ4MWE3N2M5MzZiZjk3YjRhNDEw MjhlYjA3OGI4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0xhenlMb2FkSW1hZ2VP YnNlcnZlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2 ZXIuY3BwCkBAIC04MSwxMSArODEsMjEgQEAgdm9pZCBMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6OnVu b2JzZXJ2ZShFbGVtZW50JiBlbGVtZW50LCBEb2N1bWVudCYgZG9jdW1lbnQpCiAgICAgb2JzZXJ2 ZXIubV9sYXp5TG9hZEludGVyc2VjdGlvbk9ic2VydmVyLT51bm9ic2VydmUoZWxlbWVudCk7CiB9 CiAKK3N0YXRpYyBTdHJpbmcgdmlld3BvcnREaXN0YW5jZVRocmVzaG9sZCgpCit7CisjaWYgUExB VEZPUk0oSU9TX0ZBTUlMWSkKKyAgICByZXR1cm4gZW1wdHlTdHJpbmcoKTsKKyNlbHNlCisgICAg c3RhdGljIE5ldmVyRGVzdHJveWVkPGNvbnN0IFN0cmluZz4gZGVza3RvcFZpZXdwb3J0RGlzdGFu Y2UoTUFLRV9TVEFUSUNfU1RSSU5HX0lNUEwoIjEwMHB4IDBweCIpKTsKKyAgICByZXR1cm4gZGVz a3RvcFZpZXdwb3J0RGlzdGFuY2U7CisjZW5kaWYKK30KKwogSW50ZXJzZWN0aW9uT2JzZXJ2ZXIq IExhenlMb2FkSW1hZ2VPYnNlcnZlcjo6aW50ZXJzZWN0aW9uT2JzZXJ2ZXIoRG9jdW1lbnQmIGRv Y3VtZW50KQogewogICAgIGlmICghbV9sYXp5TG9hZEludGVyc2VjdGlvbk9ic2VydmVyKSB7CiAg ICAgICAgIGF1dG8gY2FsbGJhY2sgPSBMYXp5SW1hZ2VMb2FkSW50ZXJzZWN0aW9uT2JzZXJ2ZXJD YWxsYmFjazo6Y3JlYXRlKGRvY3VtZW50KTsKLSAgICAgICAgSW50ZXJzZWN0aW9uT2JzZXJ2ZXI6 OkluaXQgb3B0aW9ucyB7IG51bGxwdHIsIGVtcHR5U3RyaW5nKCksIHsgfSB9OworICAgICAgICBJ bnRlcnNlY3Rpb25PYnNlcnZlcjo6SW5pdCBvcHRpb25zIHsgbnVsbHB0ciwgdmlld3BvcnREaXN0 YW5jZVRocmVzaG9sZCgpLCB7IH0gfTsKICAgICAgICAgYXV0byBvYnNlcnZlciA9IEludGVyc2Vj dGlvbk9ic2VydmVyOjpjcmVhdGUoZG9jdW1lbnQsIFdURk1vdmUoY2FsbGJhY2spLCBXVEZNb3Zl KG9wdGlvbnMpKTsKICAgICAgICAgaWYgKG9ic2VydmVyLmhhc0V4Y2VwdGlvbigpKQogICAgICAg ICAgICAgcmV0dXJuIG51bGxwdHI7Cg== 393764 2020-03-17 10:11:33 -0700 2020-04-01 00:41:28 -0700 Patch bug-203557-20200317181131.patch text/plain 7094 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4NTEyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTI4ZmRiMWU5ZDA2NmYw NjJmODEyZTBhOWQ0NmU5YmFjNWIzZmY1ZC4uZTFmNzgwZTA0YTE4ZmIwZGY0MGQ2ODZiNDhkOWNi ZDUxMGY3M2FmMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIwLTAzLTE3ICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBXSVAuCisKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6Y29tcHV0ZUludGVyc2VjdGlvblN0YXRlKToKKyAgICAgICAg KiBodG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXp5 TG9hZEltYWdlT2JzZXJ2ZXI6OmludGVyc2VjdGlvbk9ic2VydmVyKToKKyAgICAgICAgKiBwYWdl L0ZyYW1lVmlldy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZVZpZXc6OmNvdmVyYWdlUmVj dCBjb25zdCk6CisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuaDoKKyAgICAgICAgKiBwYWdlL0lu dGVyc2VjdGlvbk9ic2VydmVyLmg6CisgICAgICAgIChXZWJDb3JlOjpJbnRlcnNlY3Rpb25PYnNl cnZlcjo6ZGV0ZXJtaW5lRHluYW1pY1Jvb3RNYXJnaW4gY29uc3QpOgorICAgICAgICAoV2ViQ29y ZTo6SW50ZXJzZWN0aW9uT2JzZXJ2ZXI6OnNldERldGVybWluZUR5bmFtaWNSb290TWFyZ2luKToK KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xheWVyLmg6CisgICAgICAgIChX ZWJDb3JlOjpHcmFwaGljc0xheWVyOjpjb3ZlcmFnZVJlY3QgY29uc3QpOgorICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL2NhL0dyYXBoaWNzTGF5ZXJDQS5oOgorICAgICAgICAoV2ViQ29yZTo6 R3JhcGhpY3NMYXllckNBOjpjb3ZlcmFnZVJlY3QgY29uc3QpOiBEZWxldGVkLgorCiAyMDIwLTAz LTE2ICBTaW1vbiBGcmFzZXIgIDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgogCiAgICAgICAgIFJl bW92ZSBGcmFtZVZpZXc6OnNjaGVkdWxlUmVuZGVyaW5nVXBkYXRlKCkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1l bnQuY3BwCmluZGV4IGY2NTY3M2FiODFlMTU5ZjQxN2ExOTJlZWQyNGE5MDkwZjI3ZjI5MzIuLmQ3 YzlmYzJjYWY0ZmI1ZjlkNWU2MWYyZmQxYWQ5MzhhMDUyY2FkZmIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3Vt ZW50LmNwcApAQCAtNzU2Miw4ICs3NTYyLDE4IEBAIHN0YXRpYyBPcHRpb25hbDxJbnRlcnNlY3Rp b25PYnNlcnZhdGlvblN0YXRlPiBjb21wdXRlSW50ZXJzZWN0aW9uU3RhdGUoRnJhbWVWaWV3CiAg ICAgICAgIGxvY2FsUm9vdEJvdW5kcyA9IGZyYW1lVmlldy5sYXlvdXRWaWV3cG9ydFJlY3QoKTsK ICAgICB9CiAKLSAgICBpZiAoYXBwbHlSb290TWFyZ2luKQotICAgICAgICBleHBhbmRSb290Qm91 bmRzV2l0aFJvb3RNYXJnaW4obG9jYWxSb290Qm91bmRzLCBvYnNlcnZlci5yb290TWFyZ2luQm94 KCkpOworICAgIGlmIChhcHBseVJvb3RNYXJnaW4pIHsKKyAgICAgICAgTGVuZ3RoQm94IHJvb3RN YXJnaW47CisgICAgICAgIGlmIChvYnNlcnZlci5kZXRlcm1pbmVEeW5hbWljUm9vdE1hcmdpbigp KSB7CisgICAgICAgICAgICBhdXRvIGZsb2F0UmVjdCA9IGZyYW1lVmlldy5jb3ZlcmFnZVJlY3Qo KTsKKyAgICAgICAgICAgIGlmIChmbG9hdFJlY3QuaXNFbXB0eSgpKQorICAgICAgICAgICAgICAg IGZsb2F0UmVjdCA9IGZyYW1lVmlldy5sYXlvdXRWaWV3cG9ydFJlY3QoKTsKKyAgICAgICAgICAg IGF1dG8gaW50UmVjdCA9IGVuY2xvc2luZ0ludFJlY3QoZmxvYXRSZWN0KTsKKyAgICAgICAgICAg IHJvb3RNYXJnaW4gPSBMZW5ndGhCb3goaW50UmVjdC5oZWlnaHQoKSwgMCwgaW50UmVjdC5oZWln aHQoKSwgMCk7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgcm9vdE1hcmdpbiA9IG9ic2Vy dmVyLnJvb3RNYXJnaW5Cb3goKTsKKyAgICAgICAgZXhwYW5kUm9vdEJvdW5kc1dpdGhSb290TWFy Z2luKGxvY2FsUm9vdEJvdW5kcywgcm9vdE1hcmdpbik7CisgICAgfQogCiAgICAgTGF5b3V0UmVj dCBsb2NhbFRhcmdldEJvdW5kczsKICAgICBpZiAoaXM8UmVuZGVyQm94PigqdGFyZ2V0UmVuZGVy ZXIpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2 ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwCmlu ZGV4IDM5MThkMDIzM2RmYmU4MzM4ZWMyOGZkM2JjMjQwMTRkNzI5YWFmMjIuLjFiM2ExOTdkM2Jm YWVkOWZlM2JhZTVjNDkxYTU4ZTcyMGYwZTM2MzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHAKQEAgLTkwLDYgKzkwLDcgQEAgSW50ZXJzZWN0aW9u T2JzZXJ2ZXIqIExhenlMb2FkSW1hZ2VPYnNlcnZlcjo6aW50ZXJzZWN0aW9uT2JzZXJ2ZXIoRG9j dW1lbnQmIGRvY3UKICAgICAgICAgaWYgKG9ic2VydmVyLmhhc0V4Y2VwdGlvbigpKQogICAgICAg ICAgICAgcmV0dXJuIG51bGxwdHI7CiAgICAgICAgIG1fbGF6eUxvYWRJbnRlcnNlY3Rpb25PYnNl cnZlciA9IG9ic2VydmVyLnJldHVyblZhbHVlKCkucHRyKCk7CisgICAgICAgIG1fbGF6eUxvYWRJ bnRlcnNlY3Rpb25PYnNlcnZlci0+c2V0RGV0ZXJtaW5lRHluYW1pY1Jvb3RNYXJnaW4oKTsKICAg ICB9CiAgICAgcmV0dXJuIG1fbGF6eUxvYWRJbnRlcnNlY3Rpb25PYnNlcnZlci5nZXQoKTsKIH0K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAppbmRleCA1M2YxNzk4ZThjMmMxNWRmZDZmNTlkZWFl NmM2MGY1M2Y2M2I0MDhiLi4zYmFmMTExMmY1MTMzMTE2NTNiZDVmNTAyZWM3NjIwMzFkZGVkY2I5 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCkBAIC01MzIyLDYgKzUzMjIsMjMgQEAgYm9v bCBGcmFtZVZpZXc6OnNob3VsZFBsYWNlQmxvY2tEaXJlY3Rpb25TY3JvbGxiYXJPbkxlZnQoKSBj b25zdAogICAgIHJldHVybiByZW5kZXJWaWV3KCkgJiYgcmVuZGVyVmlldygpLT5zaG91bGRQbGFj ZUJsb2NrRGlyZWN0aW9uU2Nyb2xsYmFyT25MZWZ0KCk7CiB9CiAKK0Zsb2F0UmVjdCBGcmFtZVZp ZXc6OmNvdmVyYWdlUmVjdCgpIGNvbnN0Cit7CisgICAgUmVuZGVyVmlldyogcmVuZGVyVmlldyA9 IHRoaXMtPnJlbmRlclZpZXcoKTsKKyAgICBpZiAoIXJlbmRlclZpZXcpCisgICAgICAgIHJldHVy biBGbG9hdFJlY3QoKTsKKworICAgIFJlbmRlckxheWVyQmFja2luZyogYmFja2luZyA9IHJlbmRl clZpZXctPmxheWVyKCktPmJhY2tpbmcoKTsKKyAgICBpZiAoIWJhY2tpbmcpCisgICAgICAgIHJl dHVybiBGbG9hdFJlY3QoKTsKKworICAgIGF1dG8qIGdyYXBoaWNzTGF5ZXIgPSBiYWNraW5nLT5n cmFwaGljc0xheWVyKCk7CisgICAgaWYgKCFncmFwaGljc0xheWVyKQorICAgICAgICByZXR1cm4g RmxvYXRSZWN0KCk7CisKKyAgICByZXR1cm4gZ3JhcGhpY3NMYXllci0+Y292ZXJhZ2VSZWN0KCk7 Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI3VuZGVmIFBBR0VfSUQKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdl L0ZyYW1lVmlldy5oCmluZGV4IGMyMmU0ZTU4YzE0NDhhMmRmYzY2Zjk0NDBiNDE3MmQ3ODIyNGU2 MzAuLjAwN2Y2N2U5YWE4ZDM1ODdjYmJjNDAwMmEwYzkwNmE2N2UwZGEzMGEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9GcmFtZVZpZXcuaApAQCAtMjY3LDYgKzI2Nyw4IEBAIHB1YmxpYzoKICAgICBXRUJDT1JFX0VY UE9SVCBMYXlvdXRSZWN0IGxheW91dFZpZXdwb3J0UmVjdCgpIGNvbnN0OwogICAgIFdFQkNPUkVf RVhQT1JUIExheW91dFJlY3QgdmlzdWFsVmlld3BvcnRSZWN0KCkgY29uc3Q7CiAgICAgCisgICAg RmxvYXRSZWN0IGNvdmVyYWdlUmVjdCgpIGNvbnN0OworCiAgICAgc3RhdGljIExheW91dFJlY3Qg dmlzaWJsZURvY3VtZW50UmVjdChjb25zdCBGbG9hdFJlY3QmIHZpc2libGVDb250ZW50UmVjdCwg ZmxvYXQgaGVhZGVySGVpZ2h0LCBmbG9hdCBmb290ZXJIZWlnaHQsIGNvbnN0IEZsb2F0U2l6ZSYg dG90YWxDb250ZW50c1NpemUsIGZsb2F0IHBhZ2VTY2FsZUZhY3Rvcik7CiAKICAgICAvLyBUaGlz IGlzIGRpZmZlcmVudCB0aGFuIHZpc2libGVDb250ZW50UmVjdCgpIGluIHRoYXQgaXQgaWdub3Jl cyBuZWdhdGl2ZSAob3Igb3Zlcmx5IHBvc2l0aXZlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGFnZS9JbnRlcnNlY3Rpb25PYnNlcnZlci5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9JbnRl cnNlY3Rpb25PYnNlcnZlci5oCmluZGV4IGMxNTE2ZjhlMmJjOWE4YWMxNzEwMTUzOGEyNTQxNmE4 MzgwOTg1NmMuLmZlNWJhYThhNWFhZGM3ODdjODdlZmE5YWE3YzlmNjkzZTcxZGQzYzUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvSW50ZXJzZWN0aW9uT2JzZXJ2ZXIuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wYWdlL0ludGVyc2VjdGlvbk9ic2VydmVyLmgKQEAgLTEwNCw2ICsxMDQs OSBAQCBwdWJsaWM6CiAgICAgY29uc3QgY2hhciogYWN0aXZlRE9NT2JqZWN0TmFtZSgpIGNvbnN0 IG92ZXJyaWRlOwogICAgIHZvaWQgc3RvcCgpIG92ZXJyaWRlOwogCisgICAgYm9vbCBkZXRlcm1p bmVEeW5hbWljUm9vdE1hcmdpbigpIGNvbnN0IHsgcmV0dXJuIG1fZGV0ZXJtaW5lRHluYW1pY1Jv b3RNYXJnaW47IH0KKyAgICB2b2lkIHNldERldGVybWluZUR5bmFtaWNSb290TWFyZ2luKCkgeyBt X2RldGVybWluZUR5bmFtaWNSb290TWFyZ2luID0gdHJ1ZTsgfQorCiBwcml2YXRlOgogICAgIElu dGVyc2VjdGlvbk9ic2VydmVyKERvY3VtZW50JiwgUmVmPEludGVyc2VjdGlvbk9ic2VydmVyQ2Fs bGJhY2s+JiYsIE5vZGUqIHJvb3QsIExlbmd0aEJveCYmIHBhcnNlZFJvb3RNYXJnaW4sIFZlY3Rv cjxkb3VibGU+JiYgdGhyZXNob2xkcyk7CiAKQEAgLTExOCw2ICsxMjEsNyBAQCBwcml2YXRlOgog ICAgIFZlY3RvcjxFbGVtZW50Kj4gbV9vYnNlcnZhdGlvblRhcmdldHM7CiAgICAgVmVjdG9yPEdD UmVhY2hhYmxlUmVmPEVsZW1lbnQ+PiBtX3BlbmRpbmdUYXJnZXRzOwogICAgIFZlY3RvcjxSZWY8 SW50ZXJzZWN0aW9uT2JzZXJ2ZXJFbnRyeT4+IG1fcXVldWVkRW50cmllczsKKyAgICBib29sIG1f ZGV0ZXJtaW5lRHluYW1pY1Jvb3RNYXJnaW4geyBmYWxzZSB9OwogfTsKIAogCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xheWVyLmggYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xheWVyLmgKaW5kZXggZjBhZGVh ZTY0M2IyMDNjNDVlMzM0NDA0ZDhkYzRhMjljOTAzZTYxOS4uNjZjZjk4NGVjMDQyNTk2N2QzOTNl YjUwM2VhYjA3OTQzMTRlMzRkYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvR3JhcGhpY3NMYXllci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL0dyYXBoaWNzTGF5ZXIuaApAQCAtNjI1LDYgKzYyNSw4IEBAIHB1YmxpYzoKIAogICAg IHN0YXRpYyB2b2lkIHRyYXZlcnNlKEdyYXBoaWNzTGF5ZXImLCBjb25zdCBXVEY6OkZ1bmN0aW9u PHZvaWQgKEdyYXBoaWNzTGF5ZXImKT4mKTsKIAorICAgIHZpcnR1YWwgRmxvYXRSZWN0IGNvdmVy YWdlUmVjdCgpIGNvbnN0IHsgcmV0dXJuIEZsb2F0UmVjdCgpOyB9CisKIHByb3RlY3RlZDoKICAg ICBXRUJDT1JFX0VYUE9SVCBleHBsaWNpdCBHcmFwaGljc0xheWVyKFR5cGUsIEdyYXBoaWNzTGF5 ZXJDbGllbnQmKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2EvR3JhcGhpY3NMYXllckNBLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jYS9HcmFwaGljc0xheWVyQ0EuaAppbmRleCA3MjQzNDVlYWRiODEyZjVhYjk2YWE2MTkyNGYz MzY3NmRiZTk0NTNjLi4yOWI5N2JjNmM2Njg5Y2NiZjk4NGVhMTQ3NDdkODI0NjkwMTJkZjhlIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYS9HcmFwaGljc0xh eWVyQ0EuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYS9HcmFwaGlj c0xheWVyQ0EuaApAQCAtMzIzLDcgKzMyMyw3IEBAIHByaXZhdGU6CiAgICAgYm9vbCBhZGp1c3RD b3ZlcmFnZVJlY3QoVmlzaWJsZUFuZENvdmVyYWdlUmVjdHMmLCBjb25zdCBGbG9hdFJlY3QmIG9s ZFZpc2libGVSZWN0KSBjb25zdDsKIAogICAgIGNvbnN0IEZsb2F0UmVjdCYgdmlzaWJsZVJlY3Qo KSBjb25zdCB7IHJldHVybiBtX3Zpc2libGVSZWN0OyB9Ci0gICAgY29uc3QgRmxvYXRSZWN0JiBj b3ZlcmFnZVJlY3QoKSBjb25zdCB7IHJldHVybiBtX2NvdmVyYWdlUmVjdDsgfQorICAgIEZsb2F0 UmVjdCBjb3ZlcmFnZVJlY3QoKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiBtX2NvdmVyYWdlUmVj dDsgfQogCiAgICAgdm9pZCBzZXRWaXNpYmxlQW5kQ292ZXJhZ2VSZWN0cyhjb25zdCBWaXNpYmxl QW5kQ292ZXJhZ2VSZWN0cyYpOwogICAgIAo= 395139 2020-04-01 00:41:33 -0700 2020-04-01 01:40:48 -0700 Patch bug-203557-20200401094132.patch text/plain 1380 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5MzM2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjI3NmI5NjEzMjZiZmJi ZDE0MDAwOWE2OTY4NDczZmVhZDlkN2VkYy4uZGY0MjNhNWNhMWI2MjlhZjA5NTJkZGZjYzY5ZmY3 NTA3NmM2NDUyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDIwLTA0LTAxICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTIwMzU1NworICAgICAgICBEZXRlcm1pbmUgdmlld3BvcnQgZGlz dGFuY2VzIGZvciBsYXp5IGltYWdlIGxvYWRpbmcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBXSVAuCisKKyAgICAgICAgKiBsb2FkZXIvRG9jdW1lbnRM b2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXI6OnN0YXJ0TG9hZGlu Z01haW5SZXNvdXJjZSk6CisKIDIwMjAtMDMtMzEgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNl ckBhcHBsZS5jb20+CiAKICAgICAgICAgTWFrZSBGcmFtZVZpZXcgYW5kIEZyYW1lIFRleHRTdHJl YW0tbG9nZ2FibGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9Eb2N1bWVudExv YWRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRG9jdW1lbnRMb2FkZXIuY3BwCmluZGV4 IGRlY2Q3ZDdkZWU3OGViZDcwNmFkMjRjYTU1MDhjZWZkN2I2YTk1NjYuLmYyYjYxZTI1NGUxZDQ2 YWJlMWY1ZTc3NjRiZjI0OWYwYjZjYmMyZTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xv YWRlci9Eb2N1bWVudExvYWRlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0RvY3Vt ZW50TG9hZGVyLmNwcApAQCAtMTgyMSw3ICsxODIxLDYgQEAgdm9pZCBEb2N1bWVudExvYWRlcjo6 c3RhcnRMb2FkaW5nTWFpblJlc291cmNlKCkKICAgICAvLyBNYWtlIHN1cmUgd2UgcmUtYXBwbHkg dGhlIHVzZXIgYWdlbnQgdG8gdGhlIERvY3VtZW50J3MgUmVzb3VyY2VSZXF1ZXN0IHVwb24gcmVs b2FkIGluIGNhc2UgdGhlIGVtYmVkZGluZwogICAgIC8vIGFwcGxpY2F0aW9uIGhhcyBjaGFuZ2Vk IGl0LgogICAgIG1fcmVxdWVzdC5jbGVhckhUVFBVc2VyQWdlbnQoKTsKLSAgICBmcmFtZUxvYWRl cigpLT5hZGRFeHRyYUZpZWxkc1RvTWFpblJlc291cmNlUmVxdWVzdChtX3JlcXVlc3QpOwogCiAg ICAgQVNTRVJUKHRpbWluZygpLnN0YXJ0VGltZSgpKTsKICAgICBBU1NFUlQodGltaW5nKCkuZmV0 Y2hTdGFydCgpKTsK 395148 2020-04-01 01:40:53 -0700 2020-04-01 06:58:09 -0700 Patch bug-203557-20200401104051.patch text/plain 1486 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5MzM2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjI3NmI5NjEzMjZiZmJi ZDE0MDAwOWE2OTY4NDczZmVhZDlkN2VkYy4uZGY0MjNhNWNhMWI2MjlhZjA5NTJkZGZjYzY5ZmY3 NTA3NmM2NDUyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDIwLTA0LTAxICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTIwMzU1NworICAgICAgICBEZXRlcm1pbmUgdmlld3BvcnQgZGlz dGFuY2VzIGZvciBsYXp5IGltYWdlIGxvYWRpbmcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBXSVAuCisKKyAgICAgICAgKiBsb2FkZXIvRG9jdW1lbnRM b2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXI6OnN0YXJ0TG9hZGlu Z01haW5SZXNvdXJjZSk6CisKIDIwMjAtMDMtMzEgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNl ckBhcHBsZS5jb20+CiAKICAgICAgICAgTWFrZSBGcmFtZVZpZXcgYW5kIEZyYW1lIFRleHRTdHJl YW0tbG9nZ2FibGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9Eb2N1bWVudExv YWRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRG9jdW1lbnRMb2FkZXIuY3BwCmluZGV4 IGRlY2Q3ZDdkZWU3OGViZDcwNmFkMjRjYTU1MDhjZWZkN2I2YTk1NjYuLmQ3MmJiM2U4MzJkNGEx N2Q2YTg2ZGEzYmNmMTUyZDcyZTJiOGI5ZWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xv YWRlci9Eb2N1bWVudExvYWRlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0RvY3Vt ZW50TG9hZGVyLmNwcApAQCAtMTgxOCwxMSArMTgxOCw2IEBAIHZvaWQgRG9jdW1lbnRMb2FkZXI6 OnN0YXJ0TG9hZGluZ01haW5SZXNvdXJjZSgpCiAgICAgbV9jb250ZW50RmlsdGVyID0gIW1fc3Vi c3RpdHV0ZURhdGEuaXNWYWxpZCgpID8gQ29udGVudEZpbHRlcjo6Y3JlYXRlKCp0aGlzKSA6IG51 bGxwdHI7CiAjZW5kaWYKIAotICAgIC8vIE1ha2Ugc3VyZSB3ZSByZS1hcHBseSB0aGUgdXNlciBh Z2VudCB0byB0aGUgRG9jdW1lbnQncyBSZXNvdXJjZVJlcXVlc3QgdXBvbiByZWxvYWQgaW4gY2Fz ZSB0aGUgZW1iZWRkaW5nCi0gICAgLy8gYXBwbGljYXRpb24gaGFzIGNoYW5nZWQgaXQuCi0gICAg bV9yZXF1ZXN0LmNsZWFySFRUUFVzZXJBZ2VudCgpOwotICAgIGZyYW1lTG9hZGVyKCktPmFkZEV4 dHJhRmllbGRzVG9NYWluUmVzb3VyY2VSZXF1ZXN0KG1fcmVxdWVzdCk7Ci0KICAgICBBU1NFUlQo dGltaW5nKCkuc3RhcnRUaW1lKCkpOwogICAgIEFTU0VSVCh0aW1pbmcoKS5mZXRjaFN0YXJ0KCkp OwogCg== 395161 2020-04-01 06:58:15 -0700 2020-04-01 08:54:32 -0700 Patch bug-203557-20200401155813.patch text/plain 7427 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5MzM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDAxYmU3NmI1MGQyMTgy ZjlhYjcwNTg3YTE1ODEyNzgwZmEzMjJlYS4uZDNhZjVmYTJiOWRhMTE3NjQ1MmNjMzllN2UyMzIx NTYzZDQxMTBhOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIwLTA0LTAxICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBXSVAuCisKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6Y29tcHV0ZUludGVyc2VjdGlvblN0YXRlKToKKyAgICAgICAg KiBodG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXp5 TG9hZEltYWdlT2JzZXJ2ZXI6OmludGVyc2VjdGlvbk9ic2VydmVyKToKKyAgICAgICAgKiBwYWdl L0ZyYW1lVmlldy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZVZpZXc6OmNvdmVyYWdlUmVj dCBjb25zdCk6CisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuaDoKKyAgICAgICAgKiBwYWdlL0lu dGVyc2VjdGlvbk9ic2VydmVyLmg6CisgICAgICAgIChXZWJDb3JlOjpJbnRlcnNlY3Rpb25PYnNl cnZlcjo6ZGV0ZXJtaW5lRHluYW1pY1Jvb3RNYXJnaW4gY29uc3QpOgorICAgICAgICAoV2ViQ29y ZTo6SW50ZXJzZWN0aW9uT2JzZXJ2ZXI6OnNldERldGVybWluZUR5bmFtaWNSb290TWFyZ2luKToK KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xheWVyLmg6CisgICAgICAgIChX ZWJDb3JlOjpHcmFwaGljc0xheWVyOjpjb3ZlcmFnZVJlY3QgY29uc3QpOgorICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL2NhL0dyYXBoaWNzTGF5ZXJDQS5oOgorICAgICAgICAoV2ViQ29yZTo6 R3JhcGhpY3NMYXllckNBOjpjb3ZlcmFnZVJlY3QgY29uc3QpOiBEZWxldGVkLgorCiAyMDIwLTA0 LTAxICB5b3Vlbm4gZmFibGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4KIAogICAgICAgICBTdXBwb3J0 IHJlc29sdXRpb24gb2YgSVB2NiBTVFVOL1RVUk4gYWRkcmVzc2VzCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50 LmNwcAppbmRleCA1Zjg4MjUyYzY4ZjliNjA2NzNiMmJlZWRkNzY2NGJjZDcxNjMzZmJjLi5kMWU1 MzQxNjJhNWViM2FjMTVkYmFlN2UxMGE4ZDgyYWE4OTYzNGE2IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVu dC5jcHAKQEAgLTc1NjUsOCArNzU2NSwxOCBAQCBzdGF0aWMgT3B0aW9uYWw8SW50ZXJzZWN0aW9u T2JzZXJ2YXRpb25TdGF0ZT4gY29tcHV0ZUludGVyc2VjdGlvblN0YXRlKEZyYW1lVmlldwogICAg ICAgICBsb2NhbFJvb3RCb3VuZHMgPSBmcmFtZVZpZXcubGF5b3V0Vmlld3BvcnRSZWN0KCk7CiAg ICAgfQogCi0gICAgaWYgKGFwcGx5Um9vdE1hcmdpbikKLSAgICAgICAgZXhwYW5kUm9vdEJvdW5k c1dpdGhSb290TWFyZ2luKGxvY2FsUm9vdEJvdW5kcywgb2JzZXJ2ZXIucm9vdE1hcmdpbkJveCgp LCByb290UmVuZGVyZXItPnN0eWxlKCkuZWZmZWN0aXZlWm9vbSgpKTsKKyAgICBpZiAoYXBwbHlS b290TWFyZ2luKSB7CisgICAgICAgIExlbmd0aEJveCByb290TWFyZ2luOworICAgICAgICBpZiAo b2JzZXJ2ZXIuZGV0ZXJtaW5lRHluYW1pY1Jvb3RNYXJnaW4oKSkgeworICAgICAgICAgICAgYXV0 byBmbG9hdFJlY3QgPSBmcmFtZVZpZXcuY292ZXJhZ2VSZWN0KCk7CisgICAgICAgICAgICBpZiAo ZmxvYXRSZWN0LmlzRW1wdHkoKSkKKyAgICAgICAgICAgICAgICBmbG9hdFJlY3QgPSBmcmFtZVZp ZXcubGF5b3V0Vmlld3BvcnRSZWN0KCk7CisgICAgICAgICAgICBhdXRvIGludFJlY3QgPSBlbmNs b3NpbmdJbnRSZWN0KGZsb2F0UmVjdCk7CisgICAgICAgICAgICByb290TWFyZ2luID0gTGVuZ3Ro Qm94KGludFJlY3QuaGVpZ2h0KCksIDAsIGludFJlY3QuaGVpZ2h0KCksIDApOworICAgICAgICB9 IGVsc2UKKyAgICAgICAgICAgIHJvb3RNYXJnaW4gPSBvYnNlcnZlci5yb290TWFyZ2luQm94KCk7 CisgICAgICAgIGV4cGFuZFJvb3RCb3VuZHNXaXRoUm9vdE1hcmdpbihsb2NhbFJvb3RCb3VuZHMs IHJvb3RNYXJnaW4sIHJvb3RSZW5kZXJlci0+c3R5bGUoKS5lZmZlY3RpdmVab29tKCkpOworICAg IH0KIAogICAgIExheW91dFJlY3QgbG9jYWxUYXJnZXRCb3VuZHM7CiAgICAgaWYgKGlzPFJlbmRl ckJveD4oKnRhcmdldFJlbmRlcmVyKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv TGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvTGF6eUxvYWRJ bWFnZU9ic2VydmVyLmNwcAppbmRleCAzOTE4ZDAyMzNkZmJlODMzOGVjMjhmZDNiYzI0MDE0ZDcy OWFhZjIyLi5mNzg2MzEyNjM4NWJhNTYxYzdhZDlmNzI4MDg4NTZiZWRjMzQ0MzFiIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwCkBAIC03Nyw3ICs3 Nyw2IEBAIHZvaWQgTGF6eUxvYWRJbWFnZU9ic2VydmVyOjpvYnNlcnZlKEVsZW1lbnQmIGVsZW1l bnQpCiB2b2lkIExhenlMb2FkSW1hZ2VPYnNlcnZlcjo6dW5vYnNlcnZlKEVsZW1lbnQmIGVsZW1l bnQsIERvY3VtZW50JiBkb2N1bWVudCkKIHsKICAgICBhdXRvJiBvYnNlcnZlciA9IGRvY3VtZW50 LmxhenlMb2FkSW1hZ2VPYnNlcnZlcigpOwotICAgIEFTU0VSVChvYnNlcnZlci5pc09ic2VydmVk KGVsZW1lbnQpKTsKICAgICBvYnNlcnZlci5tX2xhenlMb2FkSW50ZXJzZWN0aW9uT2JzZXJ2ZXIt PnVub2JzZXJ2ZShlbGVtZW50KTsKIH0KIApAQCAtOTAsNiArODksNyBAQCBJbnRlcnNlY3Rpb25P YnNlcnZlciogTGF6eUxvYWRJbWFnZU9ic2VydmVyOjppbnRlcnNlY3Rpb25PYnNlcnZlcihEb2N1 bWVudCYgZG9jdQogICAgICAgICBpZiAob2JzZXJ2ZXIuaGFzRXhjZXB0aW9uKCkpCiAgICAgICAg ICAgICByZXR1cm4gbnVsbHB0cjsKICAgICAgICAgbV9sYXp5TG9hZEludGVyc2VjdGlvbk9ic2Vy dmVyID0gb2JzZXJ2ZXIucmV0dXJuVmFsdWUoKS5wdHIoKTsKKyAgICAgICAgbV9sYXp5TG9hZElu dGVyc2VjdGlvbk9ic2VydmVyLT5zZXREZXRlcm1pbmVEeW5hbWljUm9vdE1hcmdpbigpOwogICAg IH0KICAgICByZXR1cm4gbV9sYXp5TG9hZEludGVyc2VjdGlvbk9ic2VydmVyLmdldCgpOwogfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwIGIvU291cmNlL1dl YkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IDc5YTQxZTlhNGM1YjBmNjZkYzE3NmQ1ZjRk ZjhkNzFjOTE3YjdiMmYuLmYxZTUyZTEyNzdhZDgxYzIwNWY5ZmVkNTJiMjMwN2UyMDkxZDQ1MjAg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTU0NTAsNiArNTQ1MCwyMyBAQCBUZXh0 U3RyZWFtJiBvcGVyYXRvcjw8KFRleHRTdHJlYW0mIHRzLCBjb25zdCBGcmFtZVZpZXcmIHZpZXcp CiAgICAgcmV0dXJuIHRzOwogfQogCitGbG9hdFJlY3QgRnJhbWVWaWV3Ojpjb3ZlcmFnZVJlY3Qo KSBjb25zdAoreworICAgIFJlbmRlclZpZXcqIHJlbmRlclZpZXcgPSB0aGlzLT5yZW5kZXJWaWV3 KCk7CisgICAgaWYgKCFyZW5kZXJWaWV3KQorICAgICAgICByZXR1cm4gRmxvYXRSZWN0KCk7CisK KyAgICBSZW5kZXJMYXllckJhY2tpbmcqIGJhY2tpbmcgPSByZW5kZXJWaWV3LT5sYXllcigpLT5i YWNraW5nKCk7CisgICAgaWYgKCFiYWNraW5nKQorICAgICAgICByZXR1cm4gRmxvYXRSZWN0KCk7 CisKKyAgICBhdXRvKiBncmFwaGljc0xheWVyID0gYmFja2luZy0+Z3JhcGhpY3NMYXllcigpOwor ICAgIGlmICghZ3JhcGhpY3NMYXllcikKKyAgICAgICAgcmV0dXJuIEZsb2F0UmVjdCgpOworCisg ICAgcmV0dXJuIGdyYXBoaWNzTGF5ZXItPmNvdmVyYWdlUmVjdCgpOworfQorCiB9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCiAKICN1bmRlZiBQQUdFX0lECmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL0ZyYW1lVmlldy5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaAppbmRl eCBiYjk1Nzg1Y2M4MTI3YTM3ZmY2MTUwNmZmNjgxNjJmNDgxNTdkZGY0Li43ZDEyODlhNjQ2YTEw YTEwZDc1ZWU0YzZhNDhmZTZlMjljZTcyMTljIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w YWdlL0ZyYW1lVmlldy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgKQEAg LTI3MSw2ICsyNzEsOCBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9FWFBPUlQgTGF5b3V0UmVjdCBs YXlvdXRWaWV3cG9ydFJlY3QoKSBjb25zdDsKICAgICBXRUJDT1JFX0VYUE9SVCBMYXlvdXRSZWN0 IHZpc3VhbFZpZXdwb3J0UmVjdCgpIGNvbnN0OwogICAgIAorICAgIEZsb2F0UmVjdCBjb3ZlcmFn ZVJlY3QoKSBjb25zdDsKKwogICAgIHN0YXRpYyBMYXlvdXRSZWN0IHZpc2libGVEb2N1bWVudFJl Y3QoY29uc3QgRmxvYXRSZWN0JiB2aXNpYmxlQ29udGVudFJlY3QsIGZsb2F0IGhlYWRlckhlaWdo dCwgZmxvYXQgZm9vdGVySGVpZ2h0LCBjb25zdCBGbG9hdFNpemUmIHRvdGFsQ29udGVudHNTaXpl LCBmbG9hdCBwYWdlU2NhbGVGYWN0b3IpOwogCiAgICAgLy8gVGhpcyBpcyBkaWZmZXJlbnQgdGhh biB2aXNpYmxlQ29udGVudFJlY3QoKSBpbiB0aGF0IGl0IGlnbm9yZXMgbmVnYXRpdmUgKG9yIG92 ZXJseSBwb3NpdGl2ZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvSW50ZXJzZWN0 aW9uT2JzZXJ2ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvSW50ZXJzZWN0aW9uT2JzZXJ2ZXIu aAppbmRleCAxYzA4YTRlY2YzNTE2YmJhYzVlNjQ1YTA1OGJmZDczYmY4M2MwYTNiLi4zZTkxOTFm MTZjMzA3MGJlMTFhZWU2MzI3ODZhOTgyOWM1YWIwOGEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ludGVyc2VjdGlvbk9ic2VydmVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9JbnRlcnNlY3Rpb25PYnNlcnZlci5oCkBAIC05OSw2ICs5OSw5IEBAIHB1YmxpYzoKICAgICB2 b2lkIGFwcGVuZFF1ZXVlZEVudHJ5KFJlZjxJbnRlcnNlY3Rpb25PYnNlcnZlckVudHJ5PiYmKTsK ICAgICB2b2lkIG5vdGlmeSgpOwogCisgICAgYm9vbCBkZXRlcm1pbmVEeW5hbWljUm9vdE1hcmdp bigpIGNvbnN0IHsgcmV0dXJuIG1fZGV0ZXJtaW5lRHluYW1pY1Jvb3RNYXJnaW47IH0KKyAgICB2 b2lkIHNldERldGVybWluZUR5bmFtaWNSb290TWFyZ2luKCkgeyBtX2RldGVybWluZUR5bmFtaWNS b290TWFyZ2luID0gdHJ1ZTsgfQorCiBwcml2YXRlOgogICAgIEludGVyc2VjdGlvbk9ic2VydmVy KERvY3VtZW50JiwgUmVmPEludGVyc2VjdGlvbk9ic2VydmVyQ2FsbGJhY2s+JiYsIENvbnRhaW5l ck5vZGUqIHJvb3QsIExlbmd0aEJveCYmIHBhcnNlZFJvb3RNYXJnaW4sIFZlY3Rvcjxkb3VibGU+ JiYgdGhyZXNob2xkcyk7CiAKQEAgLTExOCw2ICsxMjEsNyBAQCBwcml2YXRlOgogICAgIFZlY3Rv cjxFbGVtZW50Kj4gbV9vYnNlcnZhdGlvblRhcmdldHM7CiAgICAgVmVjdG9yPEdDUmVhY2hhYmxl UmVmPEVsZW1lbnQ+PiBtX3BlbmRpbmdUYXJnZXRzOwogICAgIFZlY3RvcjxSZWY8SW50ZXJzZWN0 aW9uT2JzZXJ2ZXJFbnRyeT4+IG1fcXVldWVkRW50cmllczsKKyAgICBib29sIG1fZGV0ZXJtaW5l RHluYW1pY1Jvb3RNYXJnaW4geyBmYWxzZSB9OwogfTsKIAogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xheWVyLmggYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xheWVyLmgKaW5kZXggZjBhZGVhZTY0M2IyMDNj NDVlMzM0NDA0ZDhkYzRhMjljOTAzZTYxOS4uNjZjZjk4NGVjMDQyNTk2N2QzOTNlYjUwM2VhYjA3 OTQzMTRlMzRkYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv R3JhcGhpY3NMYXllci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dy YXBoaWNzTGF5ZXIuaApAQCAtNjI1LDYgKzYyNSw4IEBAIHB1YmxpYzoKIAogICAgIHN0YXRpYyB2 b2lkIHRyYXZlcnNlKEdyYXBoaWNzTGF5ZXImLCBjb25zdCBXVEY6OkZ1bmN0aW9uPHZvaWQgKEdy YXBoaWNzTGF5ZXImKT4mKTsKIAorICAgIHZpcnR1YWwgRmxvYXRSZWN0IGNvdmVyYWdlUmVjdCgp IGNvbnN0IHsgcmV0dXJuIEZsb2F0UmVjdCgpOyB9CisKIHByb3RlY3RlZDoKICAgICBXRUJDT1JF X0VYUE9SVCBleHBsaWNpdCBHcmFwaGljc0xheWVyKFR5cGUsIEdyYXBoaWNzTGF5ZXJDbGllbnQm KTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2EvR3Jh cGhpY3NMYXllckNBLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYS9HcmFw aGljc0xheWVyQ0EuaAppbmRleCA3MjQzNDVlYWRiODEyZjVhYjk2YWE2MTkyNGYzMzY3NmRiZTk0 NTNjLi4yOWI5N2JjNmM2Njg5Y2NiZjk4NGVhMTQ3NDdkODI0NjkwMTJkZjhlIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYS9HcmFwaGljc0xheWVyQ0EuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYS9HcmFwaGljc0xheWVyQ0Eu aApAQCAtMzIzLDcgKzMyMyw3IEBAIHByaXZhdGU6CiAgICAgYm9vbCBhZGp1c3RDb3ZlcmFnZVJl Y3QoVmlzaWJsZUFuZENvdmVyYWdlUmVjdHMmLCBjb25zdCBGbG9hdFJlY3QmIG9sZFZpc2libGVS ZWN0KSBjb25zdDsKIAogICAgIGNvbnN0IEZsb2F0UmVjdCYgdmlzaWJsZVJlY3QoKSBjb25zdCB7 IHJldHVybiBtX3Zpc2libGVSZWN0OyB9Ci0gICAgY29uc3QgRmxvYXRSZWN0JiBjb3ZlcmFnZVJl Y3QoKSBjb25zdCB7IHJldHVybiBtX2NvdmVyYWdlUmVjdDsgfQorICAgIEZsb2F0UmVjdCBjb3Zl cmFnZVJlY3QoKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiBtX2NvdmVyYWdlUmVjdDsgfQogCiAg ICAgdm9pZCBzZXRWaXNpYmxlQW5kQ292ZXJhZ2VSZWN0cyhjb25zdCBWaXNpYmxlQW5kQ292ZXJh Z2VSZWN0cyYpOwogICAgIAo= 395171 2020-04-01 08:54:37 -0700 2020-04-03 13:12:42 -0700 Patch bug-203557-20200401175435.patch text/plain 8009 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5MzM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDAxYmU3NmI1MGQyMTgy ZjlhYjcwNTg3YTE1ODEyNzgwZmEzMjJlYS4uYzk1NWM2N2Y5ZDY4MDkwNmQ4ZjYyZmU1MTgwNzkx ZDk3MDJjOWNmNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDIwLTA0LTAxICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBQcm92aWRlIGFuIEFQSSBvbiBJbnRlcnNlY3Rpb25PYnNl cnZlciB0byBkZXRlcm1pbmUKKyAgICAgICAgZHluYW1pY2FsbHkgdGhlIHJvb3QgbWFyZ2luIHRv IHVzZS4gVXNpbmcgdGhpcyBBUEksCisgICAgICAgIGZvciBsYXp5IGltYWdlIGxvYWRpbmcgdGhl IHJvb3QgbWFyZ2luIGlzIHNldCBkeW5hbWljYWxseQorICAgICAgICB0byBjb21wb3NpdG9yIGNv dmVyYWdlIHJlY3RhbmdsZSBpbmZvcm1hdGlvbiBpZgorICAgICAgICBhdmFpbGFibGUgYW5kIHZp ZXdwb3J0IGhlaWdodCBvdGhlcndpc2UuCisKKyAgICAgICAgVGhlIEFTU0VSVCBpbiBMYXp5TG9h ZEltYWdlT2JzZXJ2ZXI6OnVub2JzZXJ2ZSBpcyByZW1vdmVkCisgICAgICAgIGJlY2F1c2UgZHVl IHRvIHRpbWluZyBpc3N1ZXMgZHVwbGljYXRlIHRhcmdldCBlbnRyaWVzCisgICAgICAgIGNhbiBi ZSBpbiB0aGUgaW50ZXJzZWN0aW9uIHF1ZXVlLCBob3dldmVyIG5vdGUKKyAgICAgICAgSW50ZXJz ZWN0aW9uT2JzZXJ2ZXI6OnVub2JzZXJ2ZSBkb2VzIG5vdCBkbyB0aGUgQVNTRVJUCisgICAgICAg IGVpdGhlciBidXQgcmV0dXJucyBlYXJseSBpbiB0aGF0IGNhc2UuCisKKyAgICAgICAgKiBkb20v RG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y29tcHV0ZUludGVyc2VjdGlvblN0YXRl KToKKyAgICAgICAgKiBodG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6OmludGVyc2VjdGlvbk9ic2VydmVyKToKKyAg ICAgICAgKiBwYWdlL0ZyYW1lVmlldy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZVZpZXc6 OmNvdmVyYWdlUmVjdCBjb25zdCk6CisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuaDoKKyAgICAg ICAgKiBwYWdlL0ludGVyc2VjdGlvbk9ic2VydmVyLmg6CisgICAgICAgIChXZWJDb3JlOjpJbnRl cnNlY3Rpb25PYnNlcnZlcjo6ZGV0ZXJtaW5lRHluYW1pY1Jvb3RNYXJnaW4gY29uc3QpOgorICAg ICAgICAoV2ViQ29yZTo6SW50ZXJzZWN0aW9uT2JzZXJ2ZXI6OnNldERldGVybWluZUR5bmFtaWNS b290TWFyZ2luKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xheWVyLmg6 CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0xheWVyOjpjb3ZlcmFnZVJlY3QgY29uc3QpOgor ICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2NhL0dyYXBoaWNzTGF5ZXJDQS5oOgorICAgICAg ICAoV2ViQ29yZTo6R3JhcGhpY3NMYXllckNBOjpjb3ZlcmFnZVJlY3QgY29uc3QpOiBEZWxldGVk LgorCiAyMDIwLTA0LTAxICB5b3Vlbm4gZmFibGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4KIAogICAg ICAgICBTdXBwb3J0IHJlc29sdXRpb24gb2YgSVB2NiBTVFVOL1RVUk4gYWRkcmVzc2VzCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUv ZG9tL0RvY3VtZW50LmNwcAppbmRleCA1Zjg4MjUyYzY4ZjliNjA2NzNiMmJlZWRkNzY2NGJjZDcx NjMzZmJjLi5kMWU1MzQxNjJhNWViM2FjMTVkYmFlN2UxMGE4ZDgyYWE4OTYzNGE2IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2RvbS9Eb2N1bWVudC5jcHAKQEAgLTc1NjUsOCArNzU2NSwxOCBAQCBzdGF0aWMgT3B0aW9uYWw8 SW50ZXJzZWN0aW9uT2JzZXJ2YXRpb25TdGF0ZT4gY29tcHV0ZUludGVyc2VjdGlvblN0YXRlKEZy YW1lVmlldwogICAgICAgICBsb2NhbFJvb3RCb3VuZHMgPSBmcmFtZVZpZXcubGF5b3V0Vmlld3Bv cnRSZWN0KCk7CiAgICAgfQogCi0gICAgaWYgKGFwcGx5Um9vdE1hcmdpbikKLSAgICAgICAgZXhw YW5kUm9vdEJvdW5kc1dpdGhSb290TWFyZ2luKGxvY2FsUm9vdEJvdW5kcywgb2JzZXJ2ZXIucm9v dE1hcmdpbkJveCgpLCByb290UmVuZGVyZXItPnN0eWxlKCkuZWZmZWN0aXZlWm9vbSgpKTsKKyAg ICBpZiAoYXBwbHlSb290TWFyZ2luKSB7CisgICAgICAgIExlbmd0aEJveCByb290TWFyZ2luOwor ICAgICAgICBpZiAob2JzZXJ2ZXIuZGV0ZXJtaW5lRHluYW1pY1Jvb3RNYXJnaW4oKSkgeworICAg ICAgICAgICAgYXV0byBmbG9hdFJlY3QgPSBmcmFtZVZpZXcuY292ZXJhZ2VSZWN0KCk7CisgICAg ICAgICAgICBpZiAoZmxvYXRSZWN0LmlzRW1wdHkoKSkKKyAgICAgICAgICAgICAgICBmbG9hdFJl Y3QgPSBmcmFtZVZpZXcubGF5b3V0Vmlld3BvcnRSZWN0KCk7CisgICAgICAgICAgICBhdXRvIGlu dFJlY3QgPSBlbmNsb3NpbmdJbnRSZWN0KGZsb2F0UmVjdCk7CisgICAgICAgICAgICByb290TWFy Z2luID0gTGVuZ3RoQm94KGludFJlY3QuaGVpZ2h0KCksIDAsIGludFJlY3QuaGVpZ2h0KCksIDAp OworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIHJvb3RNYXJnaW4gPSBvYnNlcnZlci5yb290 TWFyZ2luQm94KCk7CisgICAgICAgIGV4cGFuZFJvb3RCb3VuZHNXaXRoUm9vdE1hcmdpbihsb2Nh bFJvb3RCb3VuZHMsIHJvb3RNYXJnaW4sIHJvb3RSZW5kZXJlci0+c3R5bGUoKS5lZmZlY3RpdmVa b29tKCkpOworICAgIH0KIAogICAgIExheW91dFJlY3QgbG9jYWxUYXJnZXRCb3VuZHM7CiAgICAg aWYgKGlzPFJlbmRlckJveD4oKnRhcmdldFJlbmRlcmVyKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0 bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcAppbmRleCAzOTE4ZDAyMzNkZmJlODMzOGVjMjhm ZDNiYzI0MDE0ZDcyOWFhZjIyLi5mNzg2MzEyNjM4NWJhNTYxYzdhZDlmNzI4MDg4NTZiZWRjMzQ0 MzFiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZl ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3Bw CkBAIC03Nyw3ICs3Nyw2IEBAIHZvaWQgTGF6eUxvYWRJbWFnZU9ic2VydmVyOjpvYnNlcnZlKEVs ZW1lbnQmIGVsZW1lbnQpCiB2b2lkIExhenlMb2FkSW1hZ2VPYnNlcnZlcjo6dW5vYnNlcnZlKEVs ZW1lbnQmIGVsZW1lbnQsIERvY3VtZW50JiBkb2N1bWVudCkKIHsKICAgICBhdXRvJiBvYnNlcnZl ciA9IGRvY3VtZW50LmxhenlMb2FkSW1hZ2VPYnNlcnZlcigpOwotICAgIEFTU0VSVChvYnNlcnZl ci5pc09ic2VydmVkKGVsZW1lbnQpKTsKICAgICBvYnNlcnZlci5tX2xhenlMb2FkSW50ZXJzZWN0 aW9uT2JzZXJ2ZXItPnVub2JzZXJ2ZShlbGVtZW50KTsKIH0KIApAQCAtOTAsNiArODksNyBAQCBJ bnRlcnNlY3Rpb25PYnNlcnZlciogTGF6eUxvYWRJbWFnZU9ic2VydmVyOjppbnRlcnNlY3Rpb25P YnNlcnZlcihEb2N1bWVudCYgZG9jdQogICAgICAgICBpZiAob2JzZXJ2ZXIuaGFzRXhjZXB0aW9u KCkpCiAgICAgICAgICAgICByZXR1cm4gbnVsbHB0cjsKICAgICAgICAgbV9sYXp5TG9hZEludGVy c2VjdGlvbk9ic2VydmVyID0gb2JzZXJ2ZXIucmV0dXJuVmFsdWUoKS5wdHIoKTsKKyAgICAgICAg bV9sYXp5TG9hZEludGVyc2VjdGlvbk9ic2VydmVyLT5zZXREZXRlcm1pbmVEeW5hbWljUm9vdE1h cmdpbigpOwogICAgIH0KICAgICByZXR1cm4gbV9sYXp5TG9hZEludGVyc2VjdGlvbk9ic2VydmVy LmdldCgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3Bw IGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IDc5YTQxZTlhNGM1YjBm NjZkYzE3NmQ1ZjRkZjhkNzFjOTE3YjdiMmYuLmYxZTUyZTEyNzdhZDgxYzIwNWY5ZmVkNTJiMjMw N2UyMDkxZDQ1MjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTU0NTAsNiArNTQ1 MCwyMyBAQCBUZXh0U3RyZWFtJiBvcGVyYXRvcjw8KFRleHRTdHJlYW0mIHRzLCBjb25zdCBGcmFt ZVZpZXcmIHZpZXcpCiAgICAgcmV0dXJuIHRzOwogfQogCitGbG9hdFJlY3QgRnJhbWVWaWV3Ojpj b3ZlcmFnZVJlY3QoKSBjb25zdAoreworICAgIFJlbmRlclZpZXcqIHJlbmRlclZpZXcgPSB0aGlz LT5yZW5kZXJWaWV3KCk7CisgICAgaWYgKCFyZW5kZXJWaWV3KQorICAgICAgICByZXR1cm4gRmxv YXRSZWN0KCk7CisKKyAgICBSZW5kZXJMYXllckJhY2tpbmcqIGJhY2tpbmcgPSByZW5kZXJWaWV3 LT5sYXllcigpLT5iYWNraW5nKCk7CisgICAgaWYgKCFiYWNraW5nKQorICAgICAgICByZXR1cm4g RmxvYXRSZWN0KCk7CisKKyAgICBhdXRvKiBncmFwaGljc0xheWVyID0gYmFja2luZy0+Z3JhcGhp Y3NMYXllcigpOworICAgIGlmICghZ3JhcGhpY3NMYXllcikKKyAgICAgICAgcmV0dXJuIEZsb2F0 UmVjdCgpOworCisgICAgcmV0dXJuIGdyYXBoaWNzTGF5ZXItPmNvdmVyYWdlUmVjdCgpOworfQor CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICN1bmRlZiBQQUdFX0lECmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFt ZVZpZXcuaAppbmRleCBiYjk1Nzg1Y2M4MTI3YTM3ZmY2MTUwNmZmNjgxNjJmNDgxNTdkZGY0Li43 ZDEyODlhNjQ2YTEwYTEwZDc1ZWU0YzZhNDhmZTZlMjljZTcyMTljIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJh bWVWaWV3LmgKQEAgLTI3MSw2ICsyNzEsOCBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9FWFBPUlQg TGF5b3V0UmVjdCBsYXlvdXRWaWV3cG9ydFJlY3QoKSBjb25zdDsKICAgICBXRUJDT1JFX0VYUE9S VCBMYXlvdXRSZWN0IHZpc3VhbFZpZXdwb3J0UmVjdCgpIGNvbnN0OwogICAgIAorICAgIEZsb2F0 UmVjdCBjb3ZlcmFnZVJlY3QoKSBjb25zdDsKKwogICAgIHN0YXRpYyBMYXlvdXRSZWN0IHZpc2li bGVEb2N1bWVudFJlY3QoY29uc3QgRmxvYXRSZWN0JiB2aXNpYmxlQ29udGVudFJlY3QsIGZsb2F0 IGhlYWRlckhlaWdodCwgZmxvYXQgZm9vdGVySGVpZ2h0LCBjb25zdCBGbG9hdFNpemUmIHRvdGFs Q29udGVudHNTaXplLCBmbG9hdCBwYWdlU2NhbGVGYWN0b3IpOwogCiAgICAgLy8gVGhpcyBpcyBk aWZmZXJlbnQgdGhhbiB2aXNpYmxlQ29udGVudFJlY3QoKSBpbiB0aGF0IGl0IGlnbm9yZXMgbmVn YXRpdmUgKG9yIG92ZXJseSBwb3NpdGl2ZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvSW50ZXJzZWN0aW9uT2JzZXJ2ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvSW50ZXJzZWN0 aW9uT2JzZXJ2ZXIuaAppbmRleCAxYzA4YTRlY2YzNTE2YmJhYzVlNjQ1YTA1OGJmZDczYmY4M2Mw YTNiLi4zZTkxOTFmMTZjMzA3MGJlMTFhZWU2MzI3ODZhOTgyOWM1YWIwOGEyIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ludGVyc2VjdGlvbk9ic2VydmVyLmgKKysrIGIvU291cmNl L1dlYkNvcmUvcGFnZS9JbnRlcnNlY3Rpb25PYnNlcnZlci5oCkBAIC05OSw2ICs5OSw5IEBAIHB1 YmxpYzoKICAgICB2b2lkIGFwcGVuZFF1ZXVlZEVudHJ5KFJlZjxJbnRlcnNlY3Rpb25PYnNlcnZl ckVudHJ5PiYmKTsKICAgICB2b2lkIG5vdGlmeSgpOwogCisgICAgYm9vbCBkZXRlcm1pbmVEeW5h bWljUm9vdE1hcmdpbigpIGNvbnN0IHsgcmV0dXJuIG1fZGV0ZXJtaW5lRHluYW1pY1Jvb3RNYXJn aW47IH0KKyAgICB2b2lkIHNldERldGVybWluZUR5bmFtaWNSb290TWFyZ2luKCkgeyBtX2RldGVy bWluZUR5bmFtaWNSb290TWFyZ2luID0gdHJ1ZTsgfQorCiBwcml2YXRlOgogICAgIEludGVyc2Vj dGlvbk9ic2VydmVyKERvY3VtZW50JiwgUmVmPEludGVyc2VjdGlvbk9ic2VydmVyQ2FsbGJhY2s+ JiYsIENvbnRhaW5lck5vZGUqIHJvb3QsIExlbmd0aEJveCYmIHBhcnNlZFJvb3RNYXJnaW4sIFZl Y3Rvcjxkb3VibGU+JiYgdGhyZXNob2xkcyk7CiAKQEAgLTExOCw2ICsxMjEsNyBAQCBwcml2YXRl OgogICAgIFZlY3RvcjxFbGVtZW50Kj4gbV9vYnNlcnZhdGlvblRhcmdldHM7CiAgICAgVmVjdG9y PEdDUmVhY2hhYmxlUmVmPEVsZW1lbnQ+PiBtX3BlbmRpbmdUYXJnZXRzOwogICAgIFZlY3RvcjxS ZWY8SW50ZXJzZWN0aW9uT2JzZXJ2ZXJFbnRyeT4+IG1fcXVldWVkRW50cmllczsKKyAgICBib29s IG1fZGV0ZXJtaW5lRHluYW1pY1Jvb3RNYXJnaW4geyBmYWxzZSB9OwogfTsKIAogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xheWVyLmggYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xheWVyLmgKaW5kZXggZjBh ZGVhZTY0M2IyMDNjNDVlMzM0NDA0ZDhkYzRhMjljOTAzZTYxOS4uNjZjZjk4NGVjMDQyNTk2N2Qz OTNlYjUwM2VhYjA3OTQzMTRlMzRkYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvR3JhcGhpY3NMYXllci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL0dyYXBoaWNzTGF5ZXIuaApAQCAtNjI1LDYgKzYyNSw4IEBAIHB1YmxpYzoKIAog ICAgIHN0YXRpYyB2b2lkIHRyYXZlcnNlKEdyYXBoaWNzTGF5ZXImLCBjb25zdCBXVEY6OkZ1bmN0 aW9uPHZvaWQgKEdyYXBoaWNzTGF5ZXImKT4mKTsKIAorICAgIHZpcnR1YWwgRmxvYXRSZWN0IGNv dmVyYWdlUmVjdCgpIGNvbnN0IHsgcmV0dXJuIEZsb2F0UmVjdCgpOyB9CisKIHByb3RlY3RlZDoK ICAgICBXRUJDT1JFX0VYUE9SVCBleHBsaWNpdCBHcmFwaGljc0xheWVyKFR5cGUsIEdyYXBoaWNz TGF5ZXJDbGllbnQmKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2EvR3JhcGhpY3NMYXllckNBLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jYS9HcmFwaGljc0xheWVyQ0EuaAppbmRleCA3MjQzNDVlYWRiODEyZjVhYjk2YWE2MTky NGYzMzY3NmRiZTk0NTNjLi4yOWI5N2JjNmM2Njg5Y2NiZjk4NGVhMTQ3NDdkODI0NjkwMTJkZjhl IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYS9HcmFwaGlj c0xheWVyQ0EuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYS9HcmFw aGljc0xheWVyQ0EuaApAQCAtMzIzLDcgKzMyMyw3IEBAIHByaXZhdGU6CiAgICAgYm9vbCBhZGp1 c3RDb3ZlcmFnZVJlY3QoVmlzaWJsZUFuZENvdmVyYWdlUmVjdHMmLCBjb25zdCBGbG9hdFJlY3Qm IG9sZFZpc2libGVSZWN0KSBjb25zdDsKIAogICAgIGNvbnN0IEZsb2F0UmVjdCYgdmlzaWJsZVJl Y3QoKSBjb25zdCB7IHJldHVybiBtX3Zpc2libGVSZWN0OyB9Ci0gICAgY29uc3QgRmxvYXRSZWN0 JiBjb3ZlcmFnZVJlY3QoKSBjb25zdCB7IHJldHVybiBtX2NvdmVyYWdlUmVjdDsgfQorICAgIEZs b2F0UmVjdCBjb3ZlcmFnZVJlY3QoKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiBtX2NvdmVyYWdl UmVjdDsgfQogCiAgICAgdm9pZCBzZXRWaXNpYmxlQW5kQ292ZXJhZ2VSZWN0cyhjb25zdCBWaXNp YmxlQW5kQ292ZXJhZ2VSZWN0cyYpOwogICAgIAo= 395407 2020-04-03 13:12:49 -0700 2020-04-06 12:06:28 -0700 Patch bug-203557-20200403221247.patch text/plain 8173 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5NDU0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTIzZDdlMTcwNmNmMWY5 ZmYxMDZkMmEyOTRhZjQ3MTE5Yjk5ZjUzOS4uM2QzMzA0NzBkMjVhMDFjODg5MDU5NzUyZTJjZjQ3 OGRmOTFkOWZiYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDIwLTA0LTAzICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBQcm92aWRlIGFuIEFQSSBvbiBJbnRlcnNlY3Rpb25PYnNl cnZlciB0byBkZXRlcm1pbmUKKyAgICAgICAgZHluYW1pY2FsbHkgdGhlIHJvb3QgbWFyZ2luIHRv IHVzZS4gVXNpbmcgdGhpcyBBUEksCisgICAgICAgIGZvciBsYXp5IGltYWdlIGxvYWRpbmcgdGhl IHJvb3QgbWFyZ2luIGlzIHNldCBkeW5hbWljYWxseQorICAgICAgICB0byBjb21wb3NpdG9yIGNv dmVyYWdlIHJlY3RhbmdsZSBpbmZvcm1hdGlvbiBpZgorICAgICAgICBhdmFpbGFibGUgYW5kIHZp ZXdwb3J0IGhlaWdodCBvdGhlcndpc2UuCisKKyAgICAgICAgVGhlIEFTU0VSVCBpbiBMYXp5TG9h ZEltYWdlT2JzZXJ2ZXI6OnVub2JzZXJ2ZSBpcyByZW1vdmVkCisgICAgICAgIGJlY2F1c2UgZHVl IHRvIHRpbWluZyBpc3N1ZXMgZHVwbGljYXRlIHRhcmdldCBlbnRyaWVzCisgICAgICAgIGNhbiBi ZSBpbiB0aGUgaW50ZXJzZWN0aW9uIHF1ZXVlLCBob3dldmVyIG5vdGUKKyAgICAgICAgSW50ZXJz ZWN0aW9uT2JzZXJ2ZXI6OnVub2JzZXJ2ZSBkb2VzIG5vdCBkbyB0aGUgQVNTRVJUCisgICAgICAg IGVpdGhlciBidXQgcmV0dXJucyBlYXJseSBpbiB0aGF0IGNhc2UuCisKKyAgICAgICAgKiBkb20v RG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y29tcHV0ZUludGVyc2VjdGlvblN0YXRl KToKKyAgICAgICAgKiBodG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6OnVub2JzZXJ2ZSk6CisgICAgICAgIChXZWJD b3JlOjpMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6OmludGVyc2VjdGlvbk9ic2VydmVyKToKKyAgICAg ICAgKiBwYWdlL0ZyYW1lVmlldy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZVZpZXc6OmNv dmVyYWdlUmVjdCBjb25zdCk6CisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuaDoKKyAgICAgICAg KiBwYWdlL0ludGVyc2VjdGlvbk9ic2VydmVyLmg6CisgICAgICAgIChXZWJDb3JlOjpJbnRlcnNl Y3Rpb25PYnNlcnZlcjo6ZGV0ZXJtaW5lUGFpbnRDb3ZlcmFnZVJvb3RNYXJnaW4gY29uc3QpOgor ICAgICAgICAoV2ViQ29yZTo6SW50ZXJzZWN0aW9uT2JzZXJ2ZXI6OnNldERldGVybWluZVBhaW50 Q292ZXJhZ2VSb290TWFyZ2luKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGlj c0xheWVyLmg6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0xheWVyOjpjb3ZlcmFnZVJlY3Qg Y29uc3QpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2NhL0dyYXBoaWNzTGF5ZXJDQS5o OgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NMYXllckNBOjpjb3ZlcmFnZVJlY3QgY29uc3Qp OiBEZWxldGVkLgorCiAyMDIwLTA0LTAzICB5b3Vlbm4gZmFibGV0ICA8eW91ZW5uQGFwcGxlLmNv bT4KIAogICAgICAgICBBZGQgaW5pdGlhbCBzdXBwb3J0IGZvciBXZWJSVEMgSEVWQwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2Rv bS9Eb2N1bWVudC5jcHAKaW5kZXggM2VmOTQ1OTAwYmE4ZjI0ZTAyZjVlY2YyMGRlY2ZjNzA4YmZk ODJhMC4uNGQ1YjQwMDllOTkyZDU5NzVhYzhiYTdmZjUwMzA4NzU4ZDhhZTNlYSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9k b20vRG9jdW1lbnQuY3BwCkBAIC03NTcxLDggKzc1NzEsMTkgQEAgc3RhdGljIE9wdGlvbmFsPElu dGVyc2VjdGlvbk9ic2VydmF0aW9uU3RhdGU+IGNvbXB1dGVJbnRlcnNlY3Rpb25TdGF0ZShGcmFt ZVZpZXcKICAgICAgICAgbG9jYWxSb290Qm91bmRzID0gZnJhbWVWaWV3LmxheW91dFZpZXdwb3J0 UmVjdCgpOwogICAgIH0KIAotICAgIGlmIChhcHBseVJvb3RNYXJnaW4pCi0gICAgICAgIGV4cGFu ZFJvb3RCb3VuZHNXaXRoUm9vdE1hcmdpbihsb2NhbFJvb3RCb3VuZHMsIG9ic2VydmVyLnJvb3RN YXJnaW5Cb3goKSwgcm9vdFJlbmRlcmVyLT5zdHlsZSgpLmVmZmVjdGl2ZVpvb20oKSk7CisgICAg aWYgKGFwcGx5Um9vdE1hcmdpbikgeworICAgICAgICBMZW5ndGhCb3ggcm9vdE1hcmdpbjsKKyAg ICAgICAgaWYgKG9ic2VydmVyLmRldGVybWluZVBhaW50Q292ZXJhZ2VSb290TWFyZ2luKCkpIHsK KyAgICAgICAgICAgIGF1dG8gZmxvYXRSZWN0ID0gZnJhbWVWaWV3LmNvdmVyYWdlUmVjdCgpOwor ICAgICAgICAgICAgaWYgKGZsb2F0UmVjdC5pc0VtcHR5KCkpCisgICAgICAgICAgICAgICAgZmxv YXRSZWN0ID0gZnJhbWVWaWV3LmxheW91dFZpZXdwb3J0UmVjdCgpOworICAgICAgICAgICAgYXV0 byBpbnRSZWN0ID0gZW5jbG9zaW5nSW50UmVjdChmbG9hdFJlY3QpOworICAgICAgICAgICAgZnBy aW50ZihzdGRlcnIsICJVc2luZyByZWN0ICVkXG4iLCBpbnRSZWN0LmhlaWdodCgpKTsKKyAgICAg ICAgICAgIHJvb3RNYXJnaW4gPSBMZW5ndGhCb3goaW50UmVjdC5oZWlnaHQoKSwgMCwgaW50UmVj dC5oZWlnaHQoKSwgMCk7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgcm9vdE1hcmdpbiA9 IG9ic2VydmVyLnJvb3RNYXJnaW5Cb3goKTsKKyAgICAgICAgZXhwYW5kUm9vdEJvdW5kc1dpdGhS b290TWFyZ2luKGxvY2FsUm9vdEJvdW5kcywgcm9vdE1hcmdpbiwgcm9vdFJlbmRlcmVyLT5zdHls ZSgpLmVmZmVjdGl2ZVpvb20oKSk7CisgICAgfQogCiAgICAgTGF5b3V0UmVjdCBsb2NhbFRhcmdl dEJvdW5kczsKICAgICBpZiAoaXM8UmVuZGVyQm94PigqdGFyZ2V0UmVuZGVyZXIpKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwCmluZGV4IDM5MThkMDIz M2RmYmU4MzM4ZWMyOGZkM2JjMjQwMTRkNzI5YWFmMjIuLjQyNDA1OTRmNTY2OGJjZjVmMWQyNTA4 NWU4MTA0ZTJkZjUwZTVjYmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvTGF6eUxv YWRJbWFnZU9ic2VydmVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0xhenlMb2FkSW1h Z2VPYnNlcnZlci5jcHAKQEAgLTc3LDcgKzc3LDYgQEAgdm9pZCBMYXp5TG9hZEltYWdlT2JzZXJ2 ZXI6Om9ic2VydmUoRWxlbWVudCYgZWxlbWVudCkKIHZvaWQgTGF6eUxvYWRJbWFnZU9ic2VydmVy Ojp1bm9ic2VydmUoRWxlbWVudCYgZWxlbWVudCwgRG9jdW1lbnQmIGRvY3VtZW50KQogewogICAg IGF1dG8mIG9ic2VydmVyID0gZG9jdW1lbnQubGF6eUxvYWRJbWFnZU9ic2VydmVyKCk7Ci0gICAg QVNTRVJUKG9ic2VydmVyLmlzT2JzZXJ2ZWQoZWxlbWVudCkpOwogICAgIG9ic2VydmVyLm1fbGF6 eUxvYWRJbnRlcnNlY3Rpb25PYnNlcnZlci0+dW5vYnNlcnZlKGVsZW1lbnQpOwogfQogCkBAIC05 MCw2ICs4OSw3IEBAIEludGVyc2VjdGlvbk9ic2VydmVyKiBMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6 OmludGVyc2VjdGlvbk9ic2VydmVyKERvY3VtZW50JiBkb2N1CiAgICAgICAgIGlmIChvYnNlcnZl ci5oYXNFeGNlcHRpb24oKSkKICAgICAgICAgICAgIHJldHVybiBudWxscHRyOwogICAgICAgICBt X2xhenlMb2FkSW50ZXJzZWN0aW9uT2JzZXJ2ZXIgPSBvYnNlcnZlci5yZXR1cm5WYWx1ZSgpLnB0 cigpOworICAgICAgICBtX2xhenlMb2FkSW50ZXJzZWN0aW9uT2JzZXJ2ZXItPnNldERldGVybWlu ZVBhaW50Q292ZXJhZ2VSb290TWFyZ2luKCk7CiAgICAgfQogICAgIHJldHVybiBtX2xhenlMb2Fk SW50ZXJzZWN0aW9uT2JzZXJ2ZXIuZ2V0KCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL0ZyYW1lVmlldy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAK aW5kZXggYzY4ZjVkMzhjNmU1MWUwNDg4ODcwOTRjNTdlYmZmMDdhYWYwMWNlYi4uYjk3ZTRhNzU1 MjhjOGIyMWU3MzRkNDA4YTdiYTBmOGJkNGE4ZjVmMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGFnZS9GcmFtZVZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3 LmNwcApAQCAtNTQ2NCw2ICs1NDY0LDIzIEBAIFRleHRTdHJlYW0mIG9wZXJhdG9yPDwoVGV4dFN0 cmVhbSYgdHMsIGNvbnN0IEZyYW1lVmlldyYgdmlldykKICAgICByZXR1cm4gdHM7CiB9CiAKK0Zs b2F0UmVjdCBGcmFtZVZpZXc6OmNvdmVyYWdlUmVjdCgpIGNvbnN0Cit7CisgICAgUmVuZGVyVmll dyogcmVuZGVyVmlldyA9IHRoaXMtPnJlbmRlclZpZXcoKTsKKyAgICBpZiAoIXJlbmRlclZpZXcp CisgICAgICAgIHJldHVybiBGbG9hdFJlY3QoKTsKKworICAgIFJlbmRlckxheWVyQmFja2luZyog YmFja2luZyA9IHJlbmRlclZpZXctPmxheWVyKCktPmJhY2tpbmcoKTsKKyAgICBpZiAoIWJhY2tp bmcpCisgICAgICAgIHJldHVybiBGbG9hdFJlY3QoKTsKKworICAgIGF1dG8qIGdyYXBoaWNzTGF5 ZXIgPSBiYWNraW5nLT5ncmFwaGljc0xheWVyKCk7CisgICAgaWYgKCFncmFwaGljc0xheWVyKQor ICAgICAgICByZXR1cm4gRmxvYXRSZWN0KCk7CisKKyAgICByZXR1cm4gZ3JhcGhpY3NMYXllci0+ Y292ZXJhZ2VSZWN0KCk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI3VuZGVmIFBB R0VfSUQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmggYi9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oCmluZGV4IGJiOTU3ODVjYzgxMjdhMzdmZjYxNTA2 ZmY2ODE2MmY0ODE1N2RkZjQuLjdkMTI4OWE2NDZhMTBhMTBkNzVlZTRjNmE0OGZlNmUyOWNlNzIx OWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaApAQCAtMjcxLDYgKzI3MSw4IEBAIHB1YmxpYzoK ICAgICBXRUJDT1JFX0VYUE9SVCBMYXlvdXRSZWN0IGxheW91dFZpZXdwb3J0UmVjdCgpIGNvbnN0 OwogICAgIFdFQkNPUkVfRVhQT1JUIExheW91dFJlY3QgdmlzdWFsVmlld3BvcnRSZWN0KCkgY29u c3Q7CiAgICAgCisgICAgRmxvYXRSZWN0IGNvdmVyYWdlUmVjdCgpIGNvbnN0OworCiAgICAgc3Rh dGljIExheW91dFJlY3QgdmlzaWJsZURvY3VtZW50UmVjdChjb25zdCBGbG9hdFJlY3QmIHZpc2li bGVDb250ZW50UmVjdCwgZmxvYXQgaGVhZGVySGVpZ2h0LCBmbG9hdCBmb290ZXJIZWlnaHQsIGNv bnN0IEZsb2F0U2l6ZSYgdG90YWxDb250ZW50c1NpemUsIGZsb2F0IHBhZ2VTY2FsZUZhY3Rvcik7 CiAKICAgICAvLyBUaGlzIGlzIGRpZmZlcmVudCB0aGFuIHZpc2libGVDb250ZW50UmVjdCgpIGlu IHRoYXQgaXQgaWdub3JlcyBuZWdhdGl2ZSAob3Igb3Zlcmx5IHBvc2l0aXZlKQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGFnZS9JbnRlcnNlY3Rpb25PYnNlcnZlci5oIGIvU291cmNlL1dl YkNvcmUvcGFnZS9JbnRlcnNlY3Rpb25PYnNlcnZlci5oCmluZGV4IDFjMDhhNGVjZjM1MTZiYmFj NWU2NDVhMDU4YmZkNzNiZjgzYzBhM2IuLmY0ZWRjOTVlMzAzZWE0OTBkMGRhY2MzZTBkN2Q1MTU0 MTVmNjhiYWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvSW50ZXJzZWN0aW9uT2Jz ZXJ2ZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ludGVyc2VjdGlvbk9ic2VydmVyLmgK QEAgLTk5LDYgKzk5LDkgQEAgcHVibGljOgogICAgIHZvaWQgYXBwZW5kUXVldWVkRW50cnkoUmVm PEludGVyc2VjdGlvbk9ic2VydmVyRW50cnk+JiYpOwogICAgIHZvaWQgbm90aWZ5KCk7CiAKKyAg ICBib29sIGRldGVybWluZVBhaW50Q292ZXJhZ2VSb290TWFyZ2luKCkgY29uc3QgeyByZXR1cm4g bV9kZXRlcm1pbmVQYWludENvdmVyYWdlUm9vdE1hcmdpbjsgfQorICAgIHZvaWQgc2V0RGV0ZXJt aW5lUGFpbnRDb3ZlcmFnZVJvb3RNYXJnaW4oKSB7IG1fZGV0ZXJtaW5lUGFpbnRDb3ZlcmFnZVJv b3RNYXJnaW4gPSB0cnVlOyB9CisKIHByaXZhdGU6CiAgICAgSW50ZXJzZWN0aW9uT2JzZXJ2ZXIo RG9jdW1lbnQmLCBSZWY8SW50ZXJzZWN0aW9uT2JzZXJ2ZXJDYWxsYmFjaz4mJiwgQ29udGFpbmVy Tm9kZSogcm9vdCwgTGVuZ3RoQm94JiYgcGFyc2VkUm9vdE1hcmdpbiwgVmVjdG9yPGRvdWJsZT4m JiB0aHJlc2hvbGRzKTsKIApAQCAtMTE4LDYgKzEyMSw3IEBAIHByaXZhdGU6CiAgICAgVmVjdG9y PEVsZW1lbnQqPiBtX29ic2VydmF0aW9uVGFyZ2V0czsKICAgICBWZWN0b3I8R0NSZWFjaGFibGVS ZWY8RWxlbWVudD4+IG1fcGVuZGluZ1RhcmdldHM7CiAgICAgVmVjdG9yPFJlZjxJbnRlcnNlY3Rp b25PYnNlcnZlckVudHJ5Pj4gbV9xdWV1ZWRFbnRyaWVzOworICAgIGJvb2wgbV9kZXRlcm1pbmVQ YWludENvdmVyYWdlUm9vdE1hcmdpbiB7IGZhbHNlIH07CiB9OwogCiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzTGF5ZXIuaCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzTGF5ZXIuaAppbmRleCBmMGFkZWFlNjQz YjIwM2M0NWUzMzQ0MDRkOGRjNGEyOWM5MDNlNjE5Li42NmNmOTg0ZWMwNDI1OTY3ZDM5M2ViNTAz ZWFiMDc5NDMxNGUzNGRjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9HcmFwaGljc0xheWVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvR3JhcGhpY3NMYXllci5oCkBAIC02MjUsNiArNjI1LDggQEAgcHVibGljOgogCiAgICAgc3Rh dGljIHZvaWQgdHJhdmVyc2UoR3JhcGhpY3NMYXllciYsIGNvbnN0IFdURjo6RnVuY3Rpb248dm9p ZCAoR3JhcGhpY3NMYXllciYpPiYpOwogCisgICAgdmlydHVhbCBGbG9hdFJlY3QgY292ZXJhZ2VS ZWN0KCkgY29uc3QgeyByZXR1cm4gRmxvYXRSZWN0KCk7IH0KKwogcHJvdGVjdGVkOgogICAgIFdF QkNPUkVfRVhQT1JUIGV4cGxpY2l0IEdyYXBoaWNzTGF5ZXIoVHlwZSwgR3JhcGhpY3NMYXllckNs aWVudCYpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j YS9HcmFwaGljc0xheWVyQ0EuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nh L0dyYXBoaWNzTGF5ZXJDQS5oCmluZGV4IDcyNDM0NWVhZGI4MTJmNWFiOTZhYTYxOTI0ZjMzNjc2 ZGJlOTQ1M2MuLjI5Yjk3YmM2YzY2ODljY2JmOTg0ZWExNDc0N2Q4MjQ2OTAxMmRmOGUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhL0dyYXBoaWNzTGF5ZXJD QS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhL0dyYXBoaWNzTGF5 ZXJDQS5oCkBAIC0zMjMsNyArMzIzLDcgQEAgcHJpdmF0ZToKICAgICBib29sIGFkanVzdENvdmVy YWdlUmVjdChWaXNpYmxlQW5kQ292ZXJhZ2VSZWN0cyYsIGNvbnN0IEZsb2F0UmVjdCYgb2xkVmlz aWJsZVJlY3QpIGNvbnN0OwogCiAgICAgY29uc3QgRmxvYXRSZWN0JiB2aXNpYmxlUmVjdCgpIGNv bnN0IHsgcmV0dXJuIG1fdmlzaWJsZVJlY3Q7IH0KLSAgICBjb25zdCBGbG9hdFJlY3QmIGNvdmVy YWdlUmVjdCgpIGNvbnN0IHsgcmV0dXJuIG1fY292ZXJhZ2VSZWN0OyB9CisgICAgRmxvYXRSZWN0 IGNvdmVyYWdlUmVjdCgpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIG1fY292ZXJhZ2VSZWN0OyB9 CiAKICAgICB2b2lkIHNldFZpc2libGVBbmRDb3ZlcmFnZVJlY3RzKGNvbnN0IFZpc2libGVBbmRD b3ZlcmFnZVJlY3RzJik7CiAgICAgCg== 395597 2020-04-06 12:06:33 -0700 2021-03-15 09:08:19 -0700 Patch bug-203557-20200406210631.patch text/plain 8212 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5NTgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjNhODA5YjdjOTA1NDQ4 ODcxNDY3NjQ2NTdkYzNiODAxYjVmYWVmZC4uODgzZDE2YWY4NmJhNjZiODAyYWNkYjU1M2IwMjc2 NTc3NDg1Y2U0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDIwLTA0LTA2ICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBEYXJp biBBZGxlci4KKworICAgICAgICBQcm92aWRlIGFuIEFQSSBvbiBJbnRlcnNlY3Rpb25PYnNlcnZl ciB0byBkZXRlcm1pbmUKKyAgICAgICAgZHluYW1pY2FsbHkgdGhlIHJvb3QgbWFyZ2luIHRvIHVz ZS4gVXNpbmcgdGhpcyBBUEksCisgICAgICAgIGZvciBsYXp5IGltYWdlIGxvYWRpbmcgdGhlIHJv b3QgbWFyZ2luIGlzIHNldCBkeW5hbWljYWxseQorICAgICAgICB0byBjb21wb3NpdG9yIGNvdmVy YWdlIHJlY3RhbmdsZSBpbmZvcm1hdGlvbiBpZgorICAgICAgICBhdmFpbGFibGUgYW5kIHZpZXdw b3J0IGhlaWdodCBvdGhlcndpc2UuCisKKyAgICAgICAgVGhlIEFTU0VSVCBpbiBMYXp5TG9hZElt YWdlT2JzZXJ2ZXI6OnVub2JzZXJ2ZSBpcyByZW1vdmVkCisgICAgICAgIGJlY2F1c2UgZHVlIHRv IHRpbWluZyBpc3N1ZXMgZHVwbGljYXRlIHRhcmdldCBlbnRyaWVzCisgICAgICAgIGNhbiBiZSBp biB0aGUgaW50ZXJzZWN0aW9uIHF1ZXVlLCBob3dldmVyIG5vdGUKKyAgICAgICAgSW50ZXJzZWN0 aW9uT2JzZXJ2ZXI6OnVub2JzZXJ2ZSBkb2VzIG5vdCBkbyB0aGUgQVNTRVJUCisgICAgICAgIGVp dGhlciBidXQgcmV0dXJucyBlYXJseSBpbiB0aGF0IGNhc2UuCisKKyAgICAgICAgKiBkb20vRG9j dW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y29tcHV0ZUludGVyc2VjdGlvblN0YXRlKToK KyAgICAgICAgKiBodG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6OnVub2JzZXJ2ZSk6CisgICAgICAgIChXZWJDb3Jl OjpMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6OmludGVyc2VjdGlvbk9ic2VydmVyKToKKyAgICAgICAg KiBwYWdlL0ZyYW1lVmlldy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZVZpZXc6OmNvdmVy YWdlUmVjdCBjb25zdCk6CisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuaDoKKyAgICAgICAgKiBw YWdlL0ludGVyc2VjdGlvbk9ic2VydmVyLmg6CisgICAgICAgIChXZWJDb3JlOjpJbnRlcnNlY3Rp b25PYnNlcnZlcjo6ZGV0ZXJtaW5lUGFpbnRDb3ZlcmFnZVJvb3RNYXJnaW4gY29uc3QpOgorICAg ICAgICAoV2ViQ29yZTo6SW50ZXJzZWN0aW9uT2JzZXJ2ZXI6OnNldERldGVybWluZVBhaW50Q292 ZXJhZ2VSb290TWFyZ2luKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xh eWVyLmg6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0xheWVyOjpjb3ZlcmFnZVJlY3QgY29u c3QpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2NhL0dyYXBoaWNzTGF5ZXJDQS5oOgor ICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NMYXllckNBOjpjb3ZlcmFnZVJlY3QgY29uc3QpOiBE ZWxldGVkLgorCiAyMDIwLTA0LTA2ICBTaW1vbiBGcmFzZXIgIDxzaW1vbi5mcmFzZXJAYXBwbGUu Y29tPgogCiAgICAgICAgIE1ha2UgUmVuZGVyT2JqZWN0IFRleHRTdHJlYW0tbG9nZ2FibGUKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9kb20vRG9jdW1lbnQuY3BwCmluZGV4IDg1MjE2OTJjZmI3MDcxYmY2Y2M2Y2M3OWNjMzRjOWMz OTY4NzY5MDQuLjNlNGFlODIwNWJkNjg3NTAxODliZGFkOGYzODk2OGUzMDNiODJmZTcgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvZG9tL0RvY3VtZW50LmNwcApAQCAtNzU3MSw4ICs3NTcxLDE4IEBAIHN0YXRpYyBPcHRpb25h bDxJbnRlcnNlY3Rpb25PYnNlcnZhdGlvblN0YXRlPiBjb21wdXRlSW50ZXJzZWN0aW9uU3RhdGUo RnJhbWVWaWV3CiAgICAgICAgIGxvY2FsUm9vdEJvdW5kcyA9IGZyYW1lVmlldy5sYXlvdXRWaWV3 cG9ydFJlY3QoKTsKICAgICB9CiAKLSAgICBpZiAoYXBwbHlSb290TWFyZ2luKQotICAgICAgICBl eHBhbmRSb290Qm91bmRzV2l0aFJvb3RNYXJnaW4obG9jYWxSb290Qm91bmRzLCBvYnNlcnZlci5y b290TWFyZ2luQm94KCksIHJvb3RSZW5kZXJlci0+c3R5bGUoKS5lZmZlY3RpdmVab29tKCkpOwor ICAgIGlmIChhcHBseVJvb3RNYXJnaW4pIHsKKyAgICAgICAgTGVuZ3RoQm94IHJvb3RNYXJnaW47 CisgICAgICAgIGlmIChvYnNlcnZlci5kZXRlcm1pbmVQYWludENvdmVyYWdlUm9vdE1hcmdpbigp KSB7CisgICAgICAgICAgICBhdXRvIGZsb2F0UmVjdCA9IGZyYW1lVmlldy5jb3ZlcmFnZVJlY3Qo KTsKKyAgICAgICAgICAgIGlmIChmbG9hdFJlY3QuaXNFbXB0eSgpKQorICAgICAgICAgICAgICAg IGZsb2F0UmVjdCA9IGZyYW1lVmlldy5sYXlvdXRWaWV3cG9ydFJlY3QoKTsKKyAgICAgICAgICAg IGF1dG8gaGVpZ2h0ID0gZW5jbG9zaW5nSW50UmVjdChmbG9hdFJlY3QpLmhlaWdodCgpOworICAg ICAgICAgICAgcm9vdE1hcmdpbiA9IExlbmd0aEJveChoZWlnaHQsIDAsIGhlaWdodCwgMCk7Cisg ICAgICAgIH0gZWxzZQorICAgICAgICAgICAgcm9vdE1hcmdpbiA9IG9ic2VydmVyLnJvb3RNYXJn aW5Cb3goKTsKKyAgICAgICAgZXhwYW5kUm9vdEJvdW5kc1dpdGhSb290TWFyZ2luKGxvY2FsUm9v dEJvdW5kcywgcm9vdE1hcmdpbiwgcm9vdFJlbmRlcmVyLT5zdHlsZSgpLmVmZmVjdGl2ZVpvb20o KSk7CisgICAgfQogCiAgICAgTGF5b3V0UmVjdCBsb2NhbFRhcmdldEJvdW5kczsKICAgICBpZiAo aXM8UmVuZGVyQm94PigqdGFyZ2V0UmVuZGVyZXIpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9M YXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwCmluZGV4IDM5MThkMDIzM2RmYmU4MzM4ZWMyOGZkM2Jj MjQwMTRkNzI5YWFmMjIuLjA3N2U4ZGU2Y2MxNmVmYTAzZjk0MDE1ZTNhOTA1MzI3M2RlODU3MWMg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHAKQEAg LTc2LDkgKzc2LDcgQEAgdm9pZCBMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6Om9ic2VydmUoRWxlbWVu dCYgZWxlbWVudCkKIAogdm9pZCBMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6OnVub2JzZXJ2ZShFbGVt ZW50JiBlbGVtZW50LCBEb2N1bWVudCYgZG9jdW1lbnQpCiB7Ci0gICAgYXV0byYgb2JzZXJ2ZXIg PSBkb2N1bWVudC5sYXp5TG9hZEltYWdlT2JzZXJ2ZXIoKTsKLSAgICBBU1NFUlQob2JzZXJ2ZXIu aXNPYnNlcnZlZChlbGVtZW50KSk7Ci0gICAgb2JzZXJ2ZXIubV9sYXp5TG9hZEludGVyc2VjdGlv bk9ic2VydmVyLT51bm9ic2VydmUoZWxlbWVudCk7CisgICAgZG9jdW1lbnQubGF6eUxvYWRJbWFn ZU9ic2VydmVyKCkubV9sYXp5TG9hZEludGVyc2VjdGlvbk9ic2VydmVyLT51bm9ic2VydmUoZWxl bWVudCk7CiB9CiAKIEludGVyc2VjdGlvbk9ic2VydmVyKiBMYXp5TG9hZEltYWdlT2JzZXJ2ZXI6 OmludGVyc2VjdGlvbk9ic2VydmVyKERvY3VtZW50JiBkb2N1bWVudCkKQEAgLTkwLDYgKzg4LDcg QEAgSW50ZXJzZWN0aW9uT2JzZXJ2ZXIqIExhenlMb2FkSW1hZ2VPYnNlcnZlcjo6aW50ZXJzZWN0 aW9uT2JzZXJ2ZXIoRG9jdW1lbnQmIGRvY3UKICAgICAgICAgaWYgKG9ic2VydmVyLmhhc0V4Y2Vw dGlvbigpKQogICAgICAgICAgICAgcmV0dXJuIG51bGxwdHI7CiAgICAgICAgIG1fbGF6eUxvYWRJ bnRlcnNlY3Rpb25PYnNlcnZlciA9IG9ic2VydmVyLnJldHVyblZhbHVlKCkucHRyKCk7CisgICAg ICAgIG1fbGF6eUxvYWRJbnRlcnNlY3Rpb25PYnNlcnZlci0+c2V0RGV0ZXJtaW5lUGFpbnRDb3Zl cmFnZVJvb3RNYXJnaW4oKTsKICAgICB9CiAgICAgcmV0dXJuIG1fbGF6eUxvYWRJbnRlcnNlY3Rp b25PYnNlcnZlci5nZXQoKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJh bWVWaWV3LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAppbmRleCAwMTc3 NmZjZDAxNGUyZDhjNGE3ZjdhYzdkNTExM2NhY2I0ZTM1N2NjLi45NjU4ZDVmMTU5NTJlMmFiY2Vm Nzg5YTMzYzNjYmM1OTFhMWQ3NzM5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0Zy YW1lVmlldy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCkBAIC01 NDYyLDYgKzU0NjIsMjMgQEAgVGV4dFN0cmVhbSYgb3BlcmF0b3I8PChUZXh0U3RyZWFtJiB0cywg Y29uc3QgRnJhbWVWaWV3JiB2aWV3KQogICAgIHJldHVybiB0czsKIH0KIAorRmxvYXRSZWN0IEZy YW1lVmlldzo6Y292ZXJhZ2VSZWN0KCkgY29uc3QKK3sKKyAgICBhdXRvKiB2aWV3ID0gdGhpcy0+ cmVuZGVyVmlldygpOworICAgIGlmICghdmlldykKKyAgICAgICAgcmV0dXJuIHsgfTsKKworICAg IGF1dG8qIGJhY2tpbmcgPSB2aWV3LT5sYXllcigpLT5iYWNraW5nKCk7CisgICAgaWYgKCFiYWNr aW5nKQorICAgICAgICByZXR1cm4geyB9OworCisgICAgYXV0byogZ3JhcGhpY3NMYXllciA9IGJh Y2tpbmctPmdyYXBoaWNzTGF5ZXIoKTsKKyAgICBpZiAoIWdyYXBoaWNzTGF5ZXIpCisgICAgICAg IHJldHVybiB7IH07CisKKyAgICByZXR1cm4gZ3JhcGhpY3NMYXllci0+Y292ZXJhZ2VSZWN0KCk7 Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI3VuZGVmIFBBR0VfSUQKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdl L0ZyYW1lVmlldy5oCmluZGV4IGJiOTU3ODVjYzgxMjdhMzdmZjYxNTA2ZmY2ODE2MmY0ODE1N2Rk ZjQuLjdkMTI4OWE2NDZhMTBhMTBkNzVlZTRjNmE0OGZlNmUyOWNlNzIxOWMgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9GcmFtZVZpZXcuaApAQCAtMjcxLDYgKzI3MSw4IEBAIHB1YmxpYzoKICAgICBXRUJDT1JFX0VY UE9SVCBMYXlvdXRSZWN0IGxheW91dFZpZXdwb3J0UmVjdCgpIGNvbnN0OwogICAgIFdFQkNPUkVf RVhQT1JUIExheW91dFJlY3QgdmlzdWFsVmlld3BvcnRSZWN0KCkgY29uc3Q7CiAgICAgCisgICAg RmxvYXRSZWN0IGNvdmVyYWdlUmVjdCgpIGNvbnN0OworCiAgICAgc3RhdGljIExheW91dFJlY3Qg dmlzaWJsZURvY3VtZW50UmVjdChjb25zdCBGbG9hdFJlY3QmIHZpc2libGVDb250ZW50UmVjdCwg ZmxvYXQgaGVhZGVySGVpZ2h0LCBmbG9hdCBmb290ZXJIZWlnaHQsIGNvbnN0IEZsb2F0U2l6ZSYg dG90YWxDb250ZW50c1NpemUsIGZsb2F0IHBhZ2VTY2FsZUZhY3Rvcik7CiAKICAgICAvLyBUaGlz IGlzIGRpZmZlcmVudCB0aGFuIHZpc2libGVDb250ZW50UmVjdCgpIGluIHRoYXQgaXQgaWdub3Jl cyBuZWdhdGl2ZSAob3Igb3Zlcmx5IHBvc2l0aXZlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGFnZS9JbnRlcnNlY3Rpb25PYnNlcnZlci5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9JbnRl cnNlY3Rpb25PYnNlcnZlci5oCmluZGV4IDFjMDhhNGVjZjM1MTZiYmFjNWU2NDVhMDU4YmZkNzNi ZjgzYzBhM2IuLmY0ZWRjOTVlMzAzZWE0OTBkMGRhY2MzZTBkN2Q1MTU0MTVmNjhiYWEgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvSW50ZXJzZWN0aW9uT2JzZXJ2ZXIuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wYWdlL0ludGVyc2VjdGlvbk9ic2VydmVyLmgKQEAgLTk5LDYgKzk5LDkg QEAgcHVibGljOgogICAgIHZvaWQgYXBwZW5kUXVldWVkRW50cnkoUmVmPEludGVyc2VjdGlvbk9i c2VydmVyRW50cnk+JiYpOwogICAgIHZvaWQgbm90aWZ5KCk7CiAKKyAgICBib29sIGRldGVybWlu ZVBhaW50Q292ZXJhZ2VSb290TWFyZ2luKCkgY29uc3QgeyByZXR1cm4gbV9kZXRlcm1pbmVQYWlu dENvdmVyYWdlUm9vdE1hcmdpbjsgfQorICAgIHZvaWQgc2V0RGV0ZXJtaW5lUGFpbnRDb3ZlcmFn ZVJvb3RNYXJnaW4oKSB7IG1fZGV0ZXJtaW5lUGFpbnRDb3ZlcmFnZVJvb3RNYXJnaW4gPSB0cnVl OyB9CisKIHByaXZhdGU6CiAgICAgSW50ZXJzZWN0aW9uT2JzZXJ2ZXIoRG9jdW1lbnQmLCBSZWY8 SW50ZXJzZWN0aW9uT2JzZXJ2ZXJDYWxsYmFjaz4mJiwgQ29udGFpbmVyTm9kZSogcm9vdCwgTGVu Z3RoQm94JiYgcGFyc2VkUm9vdE1hcmdpbiwgVmVjdG9yPGRvdWJsZT4mJiB0aHJlc2hvbGRzKTsK IApAQCAtMTE4LDYgKzEyMSw3IEBAIHByaXZhdGU6CiAgICAgVmVjdG9yPEVsZW1lbnQqPiBtX29i c2VydmF0aW9uVGFyZ2V0czsKICAgICBWZWN0b3I8R0NSZWFjaGFibGVSZWY8RWxlbWVudD4+IG1f cGVuZGluZ1RhcmdldHM7CiAgICAgVmVjdG9yPFJlZjxJbnRlcnNlY3Rpb25PYnNlcnZlckVudHJ5 Pj4gbV9xdWV1ZWRFbnRyaWVzOworICAgIGJvb2wgbV9kZXRlcm1pbmVQYWludENvdmVyYWdlUm9v dE1hcmdpbiB7IGZhbHNlIH07CiB9OwogCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzTGF5ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL0dyYXBoaWNzTGF5ZXIuaAppbmRleCBmMGFkZWFlNjQzYjIwM2M0NWUzMzQ0MDRk OGRjNGEyOWM5MDNlNjE5Li42NmNmOTg0ZWMwNDI1OTY3ZDM5M2ViNTAzZWFiMDc5NDMxNGUzNGRj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0xh eWVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NMYXll ci5oCkBAIC02MjUsNiArNjI1LDggQEAgcHVibGljOgogCiAgICAgc3RhdGljIHZvaWQgdHJhdmVy c2UoR3JhcGhpY3NMYXllciYsIGNvbnN0IFdURjo6RnVuY3Rpb248dm9pZCAoR3JhcGhpY3NMYXll ciYpPiYpOwogCisgICAgdmlydHVhbCBGbG9hdFJlY3QgY292ZXJhZ2VSZWN0KCkgY29uc3QgeyBy ZXR1cm4gRmxvYXRSZWN0KCk7IH0KKwogcHJvdGVjdGVkOgogICAgIFdFQkNPUkVfRVhQT1JUIGV4 cGxpY2l0IEdyYXBoaWNzTGF5ZXIoVHlwZSwgR3JhcGhpY3NMYXllckNsaWVudCYpOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYS9HcmFwaGljc0xheWVy Q0EuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhL0dyYXBoaWNzTGF5ZXJD QS5oCmluZGV4IDcyNDM0NWVhZGI4MTJmNWFiOTZhYTYxOTI0ZjMzNjc2ZGJlOTQ1M2MuLjc1MDFi ZDRlMWU5NjQzMmE5ZTdhYWFkOGRlYWMxNGM5OGEwNGMwYWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhL0dyYXBoaWNzTGF5ZXJDQS5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhL0dyYXBoaWNzTGF5ZXJDQS5oCkBAIC0zMjMs NyArMzIzLDcgQEAgcHJpdmF0ZToKICAgICBib29sIGFkanVzdENvdmVyYWdlUmVjdChWaXNpYmxl QW5kQ292ZXJhZ2VSZWN0cyYsIGNvbnN0IEZsb2F0UmVjdCYgb2xkVmlzaWJsZVJlY3QpIGNvbnN0 OwogCiAgICAgY29uc3QgRmxvYXRSZWN0JiB2aXNpYmxlUmVjdCgpIGNvbnN0IHsgcmV0dXJuIG1f dmlzaWJsZVJlY3Q7IH0KLSAgICBjb25zdCBGbG9hdFJlY3QmIGNvdmVyYWdlUmVjdCgpIGNvbnN0 IHsgcmV0dXJuIG1fY292ZXJhZ2VSZWN0OyB9CisgICAgRmxvYXRSZWN0IGNvdmVyYWdlUmVjdCgp IGNvbnN0IGZpbmFsIHsgcmV0dXJuIG1fY292ZXJhZ2VSZWN0OyB9CiAKICAgICB2b2lkIHNldFZp c2libGVBbmRDb3ZlcmFnZVJlY3RzKGNvbnN0IFZpc2libGVBbmRDb3ZlcmFnZVJlY3RzJik7CiAg ICAgCg== 423186 2021-03-15 09:08:25 -0700 2021-03-15 10:50:43 -0700 Patch bug-203557-20210315170824.patch text/plain 2535 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjc0NDEwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjU2MmZiMzlhM2VlYTc0 MDQ4NDEwZmEwMGFmYTM4OThlMDI1Mjg3MC4uNmJlZTJkYWI0N2Q4N2NkZGRlYzdmNTg4YmMxNTE4 MDkzYWNmNDk2OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIxLTAzLTE1ICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBEZXRlcm1pbmUgYXBwcm9wcmlhdGUgbGF6eSBpbWFnZSBs b2FkaW5nIHZpZXdwb3J0IGRpc3RhbmNlcyAKKyAgICAgICAgZm9yIGRlc2t0b3AgYW5kIG1vYmls ZSBkZXZpY2VzLgorCisgICAgICAgICogaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6bGF6eUxvYWRpbmdSb290TWFyZ2luKToKKyAgICAgICAgKFdlYkNv cmU6OkxhenlMb2FkSW1hZ2VPYnNlcnZlcjo6aW50ZXJzZWN0aW9uT2JzZXJ2ZXIpOgorCiAyMDIx LTAzLTE1ICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5lbkBhcHBsZS5jb20+CiAKICAgICAgICAg UkVHUkVTU0lPTihyMjcwMTg1KSBbR1RLXSBTb21lIHdlYmdsIGZhaWx1cmVzIGFmdGVyIG11bHRp dmFsdWUgc2V0dGVyIHJlZmFjdG9yCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0xh enlMb2FkSW1hZ2VPYnNlcnZlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0xhenlMb2FkSW1h Z2VPYnNlcnZlci5jcHAKaW5kZXggYWRlOWE3YzU1MzdlZTkyNmEwN2E0ZWRlY2IwY2ViMGI5YzRj ODEzYy4uNzQ4ODhlY2MxMWFlZmI3ZGYxMTU3ODI0ODQzMDE0ZGQyOTgyMDFlYyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcApAQCAtMjksNyArMjks NyBAQAogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiSFRNTEltYWdlRWxlbWVudC5oIgog I2luY2x1ZGUgIkludGVyc2VjdGlvbk9ic2VydmVyQ2FsbGJhY2suaCIKLSNpbmNsdWRlICJSZW5k ZXJTdHlsZS5oIgorI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKIAogI2luY2x1ZGUgPGxpbWl0cz4K IApAQCAtODAsMTEgKzgwLDIzIEBAIHZvaWQgTGF6eUxvYWRJbWFnZU9ic2VydmVyOjp1bm9ic2Vy dmUoRWxlbWVudCYgZWxlbWVudCwgRG9jdW1lbnQmIGRvY3VtZW50KQogICAgICAgICBvYnNlcnZl ci0+dW5vYnNlcnZlKGVsZW1lbnQpOwogfQogCitzdGF0aWMgU3RyaW5nIGxhenlMb2FkaW5nUm9v dE1hcmdpbihjb25zdCBEb2N1bWVudCYgZG9jdW1lbnQpCit7CisgICAgaWYgKGF1dG8gcmVuZGVy VmlldyA9IGRvY3VtZW50LnJlbmRlclZpZXcoKSkgeworICAgICAgICBTdHJpbmdCdWlsZGVyIGJ1 aWxkZXI7CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kTnVtYmVyKHJlbmRlclZpZXctPnZpZXdwb3J0 U2l6ZUZvckNTU1ZpZXdwb3J0VW5pdHMoKS5oZWlnaHQoKSk7CisgICAgICAgIGJ1aWxkZXIuYXBw ZW5kKCJweCAwcHgiKTsKKyAgICAgICAgcmV0dXJuIGJ1aWxkZXIudG9TdHJpbmcoKTsKKyAgICB9 CisgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPGNvbnN0IFN0cmluZz4gbGF6eUxvYWRpbmdSb290 TWFyZ2luRmFsbGJhY2soTUFLRV9TVEFUSUNfU1RSSU5HX0lNUEwoIjEyNTBweCAwcHgiKSk7Cisg ICAgcmV0dXJuIGxhenlMb2FkaW5nUm9vdE1hcmdpbkZhbGxiYWNrOworfQorCiBJbnRlcnNlY3Rp b25PYnNlcnZlciogTGF6eUxvYWRJbWFnZU9ic2VydmVyOjppbnRlcnNlY3Rpb25PYnNlcnZlcihE b2N1bWVudCYgZG9jdW1lbnQpCiB7CiAgICAgaWYgKCFtX29ic2VydmVyKSB7CiAgICAgICAgIGF1 dG8gY2FsbGJhY2sgPSBMYXp5SW1hZ2VMb2FkSW50ZXJzZWN0aW9uT2JzZXJ2ZXJDYWxsYmFjazo6 Y3JlYXRlKGRvY3VtZW50KTsKLSAgICAgICAgSW50ZXJzZWN0aW9uT2JzZXJ2ZXI6OkluaXQgb3B0 aW9ucyB7IFdURjo6bnVsbG9wdCwgZW1wdHlTdHJpbmcoKSwgeyB9IH07CisgICAgICAgIEludGVy c2VjdGlvbk9ic2VydmVyOjpJbml0IG9wdGlvbnMgeyBXVEY6Om51bGxvcHQsIGxhenlMb2FkaW5n Um9vdE1hcmdpbihkb2N1bWVudCksIHsgfSB9OwogICAgICAgICBhdXRvIG9ic2VydmVyID0gSW50 ZXJzZWN0aW9uT2JzZXJ2ZXI6OmNyZWF0ZShkb2N1bWVudCwgV1RGTW92ZShjYWxsYmFjayksIFdU Rk1vdmUob3B0aW9ucykpOwogICAgICAgICBpZiAob2JzZXJ2ZXIuaGFzRXhjZXB0aW9uKCkpCiAg ICAgICAgICAgICByZXR1cm4gbnVsbHB0cjsK 423199 2021-03-15 10:50:49 -0700 2021-09-30 06:11:45 -0700 Patch bug-203557-20210315185047.patch text/plain 2430 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjc0NDEwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjU2MmZiMzlhM2VlYTc0 MDQ4NDEwZmEwMGFmYTM4OThlMDI1Mjg3MC4uNmJlZTJkYWI0N2Q4N2NkZGRlYzdmNTg4YmMxNTE4 MDkzYWNmNDk2OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIxLTAzLTE1ICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBEZXRlcm1pbmUgYXBwcm9wcmlhdGUgbGF6eSBpbWFnZSBs b2FkaW5nIHZpZXdwb3J0IGRpc3RhbmNlcyAKKyAgICAgICAgZm9yIGRlc2t0b3AgYW5kIG1vYmls ZSBkZXZpY2VzLgorCisgICAgICAgICogaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6bGF6eUxvYWRpbmdSb290TWFyZ2luKToKKyAgICAgICAgKFdlYkNv cmU6OkxhenlMb2FkSW1hZ2VPYnNlcnZlcjo6aW50ZXJzZWN0aW9uT2JzZXJ2ZXIpOgorCiAyMDIx LTAzLTE1ICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5lbkBhcHBsZS5jb20+CiAKICAgICAgICAg UkVHUkVTU0lPTihyMjcwMTg1KSBbR1RLXSBTb21lIHdlYmdsIGZhaWx1cmVzIGFmdGVyIG11bHRp dmFsdWUgc2V0dGVyIHJlZmFjdG9yCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0xh enlMb2FkSW1hZ2VPYnNlcnZlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0xhenlMb2FkSW1h Z2VPYnNlcnZlci5jcHAKaW5kZXggYWRlOWE3YzU1MzdlZTkyNmEwN2E0ZWRlY2IwY2ViMGI5YzRj ODEzYy4uODk0MmY4ODE0OWM0NWE2YmU5NzdlMDgxNjFlNWViMGMwOTgwMGVhNSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcApAQCAtMjksNyArMjks NyBAQAogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiSFRNTEltYWdlRWxlbWVudC5oIgog I2luY2x1ZGUgIkludGVyc2VjdGlvbk9ic2VydmVyQ2FsbGJhY2suaCIKLSNpbmNsdWRlICJSZW5k ZXJTdHlsZS5oIgorI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKIAogI2luY2x1ZGUgPGxpbWl0cz4K IApAQCAtODAsMTEgKzgwLDE5IEBAIHZvaWQgTGF6eUxvYWRJbWFnZU9ic2VydmVyOjp1bm9ic2Vy dmUoRWxlbWVudCYgZWxlbWVudCwgRG9jdW1lbnQmIGRvY3VtZW50KQogICAgICAgICBvYnNlcnZl ci0+dW5vYnNlcnZlKGVsZW1lbnQpOwogfQogCitzdGF0aWMgU3RyaW5nIGxhenlMb2FkaW5nUm9v dE1hcmdpbihjb25zdCBEb2N1bWVudCYgZG9jdW1lbnQpCit7CisgICAgaWYgKGF1dG8gcmVuZGVy VmlldyA9IGRvY3VtZW50LnJlbmRlclZpZXcoKSkKKyAgICAgICAgcmV0dXJuIG1ha2VTdHJpbmco cmVuZGVyVmlldy0+dmlld3BvcnRTaXplRm9yQ1NTVmlld3BvcnRVbml0cygpLmhlaWdodCgpLCAi cHggMHB4Iik7CisgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPGNvbnN0IFN0cmluZz4gbGF6eUxv YWRpbmdSb290TWFyZ2luRmFsbGJhY2soTUFLRV9TVEFUSUNfU1RSSU5HX0lNUEwoIjEyNTBweCAw cHgiKSk7CisgICAgcmV0dXJuIGxhenlMb2FkaW5nUm9vdE1hcmdpbkZhbGxiYWNrOworfQorCiBJ bnRlcnNlY3Rpb25PYnNlcnZlciogTGF6eUxvYWRJbWFnZU9ic2VydmVyOjppbnRlcnNlY3Rpb25P YnNlcnZlcihEb2N1bWVudCYgZG9jdW1lbnQpCiB7CiAgICAgaWYgKCFtX29ic2VydmVyKSB7CiAg ICAgICAgIGF1dG8gY2FsbGJhY2sgPSBMYXp5SW1hZ2VMb2FkSW50ZXJzZWN0aW9uT2JzZXJ2ZXJD YWxsYmFjazo6Y3JlYXRlKGRvY3VtZW50KTsKLSAgICAgICAgSW50ZXJzZWN0aW9uT2JzZXJ2ZXI6 OkluaXQgb3B0aW9ucyB7IFdURjo6bnVsbG9wdCwgZW1wdHlTdHJpbmcoKSwgeyB9IH07CisgICAg ICAgIEludGVyc2VjdGlvbk9ic2VydmVyOjpJbml0IG9wdGlvbnMgeyBXVEY6Om51bGxvcHQsIGxh enlMb2FkaW5nUm9vdE1hcmdpbihkb2N1bWVudCksIHsgfSB9OwogICAgICAgICBhdXRvIG9ic2Vy dmVyID0gSW50ZXJzZWN0aW9uT2JzZXJ2ZXI6OmNyZWF0ZShkb2N1bWVudCwgV1RGTW92ZShjYWxs YmFjayksIFdURk1vdmUob3B0aW9ucykpOwogICAgICAgICBpZiAob2JzZXJ2ZXIuaGFzRXhjZXB0 aW9uKCkpCiAgICAgICAgICAgICByZXR1cm4gbnVsbHB0cjsK 439729 2021-09-30 06:11:51 -0700 2021-10-01 12:00:44 -0700 Patch bug-203557-20210930141150.patch text/plain 2005 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzMzA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTAyNmY4MmQ4MTM1MGZm MWNiYjZhMjc1OTFlMjFhYjRiNWMwM2YzYi4uOWJmZTY3NzUwMDg1MDRmY2NkYjE3YTJkZTk3MTU3 ZjE2YTFiYTU3MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIxLTA5LTMwICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBEZXRlcm1pbmUgYXBwcm9wcmlhdGUgbGF6eSBpbWFnZSBs b2FkaW5nIHZpZXdwb3J0IGRpc3RhbmNlcyAKKyAgICAgICAgZm9yIGRlc2t0b3AgYW5kIG1vYmls ZSBkZXZpY2VzIGJ5IHVzaW5nIGEgbGF6eSBsb2FkIGRpc3RhbmNlCisgICAgICAgIG9mIDF2aCBv biB0b3AgYW5kIGJvdHRvbS4KKworICAgICAgICAqIGh0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxhenlMb2FkSW1hZ2VPYnNlcnZlcjo6aW50ZXJzZWN0 aW9uT2JzZXJ2ZXIpOgorCiAyMDIxLTA5LTMwICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJj aWFAaWdhbGlhLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkIEdUSyBidWlsZCBmaXggYWZ0ZXIg cjI4MzMwNApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2Jz ZXJ2ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZEltYWdlT2JzZXJ2ZXIuY3Bw CmluZGV4IDgzNmRjODJhYTEzMDYyMmRhZDg3MWMxMDc4OGE5NzkyODVlNTFmZWYuLjIyYmViMjk4 MjQyYWQxNzFjZjMxNzhlNjM2YTAyNjcwM2Y4YzdiNjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0xhenlMb2FkSW1hZ2VPYnNlcnZlci5jcHAKQEAgLTI5LDcgKzI5LDYgQEAKICNpbmNsdWRl ICJGcmFtZS5oIgogI2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1lbnQuaCIKICNpbmNsdWRlICJJbnRl cnNlY3Rpb25PYnNlcnZlckNhbGxiYWNrLmgiCi0jaW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKIAog I2luY2x1ZGUgPGxpbWl0cz4KIApAQCAtODYsNyArODUsOCBAQCBJbnRlcnNlY3Rpb25PYnNlcnZl ciogTGF6eUxvYWRJbWFnZU9ic2VydmVyOjppbnRlcnNlY3Rpb25PYnNlcnZlcihEb2N1bWVudCYg ZG9jdQogewogICAgIGlmICghbV9vYnNlcnZlcikgewogICAgICAgICBhdXRvIGNhbGxiYWNrID0g TGF6eUltYWdlTG9hZEludGVyc2VjdGlvbk9ic2VydmVyQ2FsbGJhY2s6OmNyZWF0ZShkb2N1bWVu dCk7Ci0gICAgICAgIEludGVyc2VjdGlvbk9ic2VydmVyOjpJbml0IG9wdGlvbnMgeyBzdGQ6Om51 bGxvcHQsIGVtcHR5U3RyaW5nKCksIHsgfSB9OworICAgICAgICBzdGF0aWMgTmV2ZXJEZXN0cm95 ZWQ8Y29uc3QgU3RyaW5nPiBsYXp5TG9hZGluZ1Jvb3RNYXJnaW5GYWxsYmFjayhNQUtFX1NUQVRJ Q19TVFJJTkdfSU1QTCgiMTAwJSAwcHgiKSk7CisgICAgICAgIEludGVyc2VjdGlvbk9ic2VydmVy OjpJbml0IG9wdGlvbnMgeyBzdGQ6Om51bGxvcHQsIGxhenlMb2FkaW5nUm9vdE1hcmdpbkZhbGxi YWNrLCB7IH0gfTsKICAgICAgICAgYXV0byBvYnNlcnZlciA9IEludGVyc2VjdGlvbk9ic2VydmVy OjpjcmVhdGUoZG9jdW1lbnQsIFdURk1vdmUoY2FsbGJhY2spLCBXVEZNb3ZlKG9wdGlvbnMpKTsK ICAgICAgICAgaWYgKG9ic2VydmVyLmhhc0V4Y2VwdGlvbigpKQogICAgICAgICAgICAgcmV0dXJu IG51bGxwdHI7Cg== 439891 2021-10-01 12:00:50 -0700 2021-10-13 22:29:27 -0700 Patch bug-203557-20211001200049.patch text/plain 1987 rbuis U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzMzc3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzA1ZjBlZDk0ZGMwZWJm MjY5NWI2M2YxMGZlZDJhYjRhYzBkNGRkNi4uZWJmODE5ZmFhYjUwN2ZkMTljZjY0MGJhYWZmMmVi OTkzODI2YzQ3MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIxLTEwLTAxICBSb2Ig QnVpcyAgPHJidWlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgRGV0ZXJtaW5lIHZpZXdwb3J0IGRp c3RhbmNlcyBmb3IgbGF6eSBpbWFnZSBsb2FkaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBEZXRlcm1pbmUgYXBwcm9wcmlhdGUgbGF6eSBpbWFnZSBs b2FkaW5nIHZpZXdwb3J0IGRpc3RhbmNlcworICAgICAgICBmb3IgZGVza3RvcCBhbmQgbW9iaWxl IGRldmljZXMgYnkgdXNpbmcgYSBsYXp5IGxvYWQgZGlzdGFuY2UKKyAgICAgICAgb2Ygb25lIHZp ZXdwb3J0IGluIGFsbCBkaXJlY3Rpb25zLgorCisgICAgICAgICogaHRtbC9MYXp5TG9hZEltYWdl T2JzZXJ2ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF6eUxvYWRJbWFnZU9ic2VydmVyOjpp bnRlcnNlY3Rpb25PYnNlcnZlcik6CisKIDIwMjEtMTAtMDEgIFlvdWVubiBGYWJsZXQgIDx5b3Vl bm5AYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBzdXBwb3J0IGZvciBQdXNoRXZlbnQKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL2h0bWwvTGF6eUxvYWRJbWFnZU9ic2VydmVyLmNwcAppbmRleCA4MzZkYzgy YWExMzA2MjJkYWQ4NzFjMTA3ODhhOTc5Mjg1ZTUxZmVmLi4xNzZhNmVmZjhkOWFmZDhhNzlmZmQ4 Yzc0NmUwYzc5NzM1NDZkZDJlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0xhenlM b2FkSW1hZ2VPYnNlcnZlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9MYXp5TG9hZElt YWdlT2JzZXJ2ZXIuY3BwCkBAIC0yOSw3ICsyOSw2IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNp bmNsdWRlICJIVE1MSW1hZ2VFbGVtZW50LmgiCiAjaW5jbHVkZSAiSW50ZXJzZWN0aW9uT2JzZXJ2 ZXJDYWxsYmFjay5oIgotI2luY2x1ZGUgIlJlbmRlclN0eWxlLmgiCiAKICNpbmNsdWRlIDxsaW1p dHM+CiAKQEAgLTg2LDcgKzg1LDggQEAgSW50ZXJzZWN0aW9uT2JzZXJ2ZXIqIExhenlMb2FkSW1h Z2VPYnNlcnZlcjo6aW50ZXJzZWN0aW9uT2JzZXJ2ZXIoRG9jdW1lbnQmIGRvY3UKIHsKICAgICBp ZiAoIW1fb2JzZXJ2ZXIpIHsKICAgICAgICAgYXV0byBjYWxsYmFjayA9IExhenlJbWFnZUxvYWRJ bnRlcnNlY3Rpb25PYnNlcnZlckNhbGxiYWNrOjpjcmVhdGUoZG9jdW1lbnQpOwotICAgICAgICBJ bnRlcnNlY3Rpb25PYnNlcnZlcjo6SW5pdCBvcHRpb25zIHsgc3RkOjpudWxsb3B0LCBlbXB0eVN0 cmluZygpLCB7IH0gfTsKKyAgICAgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPGNvbnN0IFN0cmlu Zz4gbGF6eUxvYWRpbmdSb290TWFyZ2luRmFsbGJhY2soTUFLRV9TVEFUSUNfU1RSSU5HX0lNUEwo IjEwMCUiKSk7CisgICAgICAgIEludGVyc2VjdGlvbk9ic2VydmVyOjpJbml0IG9wdGlvbnMgeyBz dGQ6Om51bGxvcHQsIGxhenlMb2FkaW5nUm9vdE1hcmdpbkZhbGxiYWNrLCB7IH0gfTsKICAgICAg ICAgYXV0byBvYnNlcnZlciA9IEludGVyc2VjdGlvbk9ic2VydmVyOjpjcmVhdGUoZG9jdW1lbnQs IFdURk1vdmUoY2FsbGJhY2spLCBXVEZNb3ZlKG9wdGlvbnMpKTsKICAgICAgICAgaWYgKG9ic2Vy dmVyLmhhc0V4Y2VwdGlvbigpKQogICAgICAgICAgICAgcmV0dXJuIG51bGxwdHI7Cg==