208265 2020-02-26 14:37:37 -0800 Make Path::Path(const Path&) and Path::operator=(const Path&) cheap 2020-03-03 11:17:45 -0800 1 1 1 Unclassified WebKit WebCore Misc. WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 wenson_hsieh wenson_hsieh bdakin commit-queue darin jonlee sabouhallawa simon.fraser thorton webkit-bug-importer oldest_to_newest 1623185 0 wenson_hsieh 2020-02-26 14:37:37 -0800 We can make these behave in a more "copy-on-write” manner, such that we just set m_path when copying a new WebCore::Path, and only call CGPathCreateMutableCopy later if it is needed. 1624225 1 392046 wenson_hsieh 2020-02-28 20:50:50 -0800 Created attachment 392046 For EWS 1624322 2 webkit-bug-importer 2020-02-29 14:00:04 -0800 <rdar://problem/59922452> 1624330 3 392074 wenson_hsieh 2020-02-29 15:33:36 -0800 Created attachment 392074 Patch 1624450 4 392074 darin 2020-03-01 18:31:30 -0800 Comment on attachment 392074 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392074&action=review Looks like a great idea. I’m going to say review- because I spotted some errors that need to be fixed and I’d like to review the fixed version. > Source/WebCore/platform/graphics/cg/PathCG.cpp:101 > +void Path::copyPathBeforeMutationIfNeeded() We don’t need to add a new function for this. Every call added is right before a call to ensurePlatformPlath, except for Path::transform (see below). While the name doesn’t make this clear, ensurePlatformPath is *always* called just before modifying the path. So this code could be moved inside that function; maybe you want to rename it? > Source/WebCore/platform/graphics/cg/PathCG.cpp:108 > + if (m_path) { Should not need this if statement. The rest of the code enforces the invariant that m_copyPathBeforeMutation is only true if m_path is non-null. > Source/WebCore/platform/graphics/cg/PathCG.cpp:110 > + CGPathRelease(m_path); > + m_path = CGPathCreateMutableCopy(m_path); It’s *critical* not to release the old path before making the mutable copy. It’s possible that the other owner is no longer retaining the path and so that could be releasing the very last reference to it. This points to another possible optimization, less important but we could do it. If the reference count happens to be 1, then we got lucky and don’t need to make a mutable copy. CFGetRetainCount can be used to check if it’s 1. Although we use CGPathRetain and CGPathRelease we can use CFRetain/CFRelease/CFGetRetainCount. > Source/WebCore/platform/graphics/cg/PathCG.cpp:125 > + m_path = other.m_path; I’d prefer construction style syntax for this, rather than assignment. > Source/WebCore/platform/graphics/cg/PathCG.cpp:133 > Path::Path(Path&& other) This move constructor needs to be updated; it’s unsafe as-is. When we take the path from "other" we also need to take the m_copyPathBeforeMutation value from "other" and set it to false in other. I’d write it like this: Path::Path(Path&& other) : m_path(std::exchange(other.m_path, nullptr)) , m_copyPathBeforeMutation(std::exchange(other.m_copyPathBeforeMutation, false)) { } > Source/WebCore/platform/graphics/cg/PathCG.cpp:150 > - m_path = other.m_path ? CGPathCreateMutableCopy(other.m_path) : nullptr; > + m_path = other.m_path; > + if (m_path) { > + m_copyPathBeforeMutation = true; > + other.m_copyPathBeforeMutation = true; > + CGPathRetain(m_path); > + } This function is starting to get a bit long. There’s a great C++ idiom for avoiding this and correctly writing an assignment operator no matter how complex the rules are, once you’ve written a correct copy constructor. These lines will do the job: Path copy { other }; std::swap(m_path, copy.m_path); std::swap(m_copyPathBeforeMutation, copy.m_copyPathBeforeMutation); return *this; This takes advantage of the copy constructor and the destructor. The move assignment operator below makes the same mistake as the move constructor above: it leaves the m_copyPathBeforeMutation boolean behind on the other object instead of moving it with the path. Using this technique we can also correct the move assignment operator in a nice way. We just use the the same code as above, except for the first line: Path copy { WTFMove(other) }; std::swap(m_path, copy.m_path); std::swap(m_copyPathBeforeMutation, copy.m_copyPathBeforeMutation); return *this; Can also make both of these a bit more elegant by writing a separate swap function that swaps the two data members. If we write that then the two std::swap lines look like this: swap(*this, copy); or this: swap(copy); > Source/WebCore/platform/graphics/cg/PathCG.cpp:243 > + copyPathBeforeMutationIfNeeded(); This makes a wasteful copy. The code below uses m_path to make a new path and then releases it. There’s no reason to make a mutable copy just to do that. So this call should be omitted. > Source/WebCore/platform/graphics/cg/PathCG.cpp:330 > + copyPathBeforeMutationIfNeeded(); Could move this closer to before each of the two CGPath function calls here. It’s not needed when we call addBeziersForRoundedRect, and I think it’s easier to understand if we do it right before the function calls. 1624457 5 392074 wenson_hsieh 2020-03-01 19:53:04 -0800 Comment on attachment 392074 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392074&action=review >> Source/WebCore/platform/graphics/cg/PathCG.cpp:101 >> +void Path::copyPathBeforeMutationIfNeeded() > > We don’t need to add a new function for this. Every call added is right before a call to ensurePlatformPlath, except for Path::transform (see below). While the name doesn’t make this clear, ensurePlatformPath is *always* called just before modifying the path. So this code could be moved inside that function; maybe you want to rename it? This sounds good, but I’m not sure what I would rename ensurePlatformPath to since I don’t think it’s good for the details of this optimization to leak into all the call sites of ensurePlatformPath(). Maybe something like: - Rename ensurePlatformPath() to ensureOrCopyPlatformPathIfNeeded() and make it private. - Add a public ensurePlatformPath() method that just calls ensureOrCopyPlatformPathIfNeeded(). Does that sound reasonable? >> Source/WebCore/platform/graphics/cg/PathCG.cpp:108 >> + if (m_path) { > > Should not need this if statement. The rest of the code enforces the invariant that m_copyPathBeforeMutation is only true if m_path is non-null. Good catch. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:110 >> + m_path = CGPathCreateMutableCopy(m_path); > > It’s *critical* not to release the old path before making the mutable copy. It’s possible that the other owner is no longer retaining the path and so that could be releasing the very last reference to it. > > This points to another possible optimization, less important but we could do it. If the reference count happens to be 1, then we got lucky and don’t need to make a mutable copy. CFGetRetainCount can be used to check if it’s 1. Although we use CGPathRetain and CGPathRelease we can use CFRetain/CFRelease/CFGetRetainCount. I think I might be missing something here — without the CGPathRelease here, we’d have a memory leak when a path is copied, and then both the original and copy are mutated. i.e.: 1. We have a Path a with a +1 CGPathRef p. 2. We copy a to another Path b, which +1's CGPathRef p. 3. We mutate a, which changes a’s CGPathRef to a new copy, q. 4. a is then destroyed, which releases q. q’s retain count is 0 and it is freed. 5. b is then destroyed, which releases p. p’s retain count is 1 and it is still alive. …whereas if we release here, then p would be destroyed in (5) because it is additionally released in (3). I will add a check to avoid copying when the retain count is 1. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:125 >> + m_path = other.m_path; > > I’d prefer construction style syntax for this, rather than assignment. Ok, changed to use construction style syntax. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:133 >> Path::Path(Path&& other) > > This move constructor needs to be updated; it’s unsafe as-is. When we take the path from "other" we also need to take the m_copyPathBeforeMutation value from "other" and set it to false in other. I’d write it like this: > > Path::Path(Path&& other) > : m_path(std::exchange(other.m_path, nullptr)) > , m_copyPathBeforeMutation(std::exchange(other.m_copyPathBeforeMutation, false)) > { > } Fixed! >> Source/WebCore/platform/graphics/cg/PathCG.cpp:150 >> + } > > This function is starting to get a bit long. There’s a great C++ idiom for avoiding this and correctly writing an assignment operator no matter how complex the rules are, once you’ve written a correct copy constructor. These lines will do the job: > > Path copy { other }; > std::swap(m_path, copy.m_path); > std::swap(m_copyPathBeforeMutation, copy.m_copyPathBeforeMutation); > return *this; > > This takes advantage of the copy constructor and the destructor. > > The move assignment operator below makes the same mistake as the move constructor above: it leaves the m_copyPathBeforeMutation boolean behind on the other object instead of moving it with the path. Using this technique we can also correct the move assignment operator in a nice way. We just use the the same code as above, except for the first line: > > Path copy { WTFMove(other) }; > std::swap(m_path, copy.m_path); > std::swap(m_copyPathBeforeMutation, copy.m_copyPathBeforeMutation); > return *this; > > Can also make both of these a bit more elegant by writing a separate swap function that swaps the two data members. If we write that then the two std::swap lines look like this: > > swap(*this, copy); > > or this: > > swap(copy); Thanks! I’ve added a swap method and changed the implementations of the assignment operators to use it. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:243 >> + copyPathBeforeMutationIfNeeded(); > > This makes a wasteful copy. The code below uses m_path to make a new path and then releases it. There’s no reason to make a mutable copy just to do that. So this call should be omitted. Good point! Removed this. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:330 >> + copyPathBeforeMutationIfNeeded(); > > Could move this closer to before each of the two CGPath function calls here. It’s not needed when we call addBeziersForRoundedRect, and I think it’s easier to understand if we do it right before the function calls. I will address this by moving the logic currently in copyPathBeforeMutationIfNeeded() into what is currently called ensurePlatformPath(). 1624574 6 392074 darin 2020-03-02 09:34:38 -0800 Comment on attachment 392074 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392074&action=review >>> Source/WebCore/platform/graphics/cg/PathCG.cpp:110 >>> + m_path = CGPathCreateMutableCopy(m_path); >> >> It’s *critical* not to release the old path before making the mutable copy. It’s possible that the other owner is no longer retaining the path and so that could be releasing the very last reference to it. >> >> This points to another possible optimization, less important but we could do it. If the reference count happens to be 1, then we got lucky and don’t need to make a mutable copy. CFGetRetainCount can be used to check if it’s 1. Although we use CGPathRetain and CGPathRelease we can use CFRetain/CFRelease/CFGetRetainCount. > > I think I might be missing something here — without the CGPathRelease here, we’d have a memory leak when a path is copied, and then both the original and copy are mutated. i.e.: > > 1. We have a Path a with a +1 CGPathRef p. > 2. We copy a to another Path b, which +1's CGPathRef p. > 3. We mutate a, which changes a’s CGPathRef to a new copy, q. > 4. a is then destroyed, which releases q. q’s retain count is 0 and it is freed. > 5. b is then destroyed, which releases p. p’s retain count is 1 and it is still alive. > > …whereas if we release here, then p would be destroyed in (5) because it is additionally released in (3). > > I will add a check to avoid copying when the retain count is 1. My point was about the *order* of operations. The code I was reviewing could *destroy* the path by calling CGPathRelease and then call CGPathCreateMutableCopy on the destroyed path. Need to copy *before* releasing in case the retain count is 1. But if you special case the retain count of 1 that is one way of taking care of it. 1624580 7 392074 wenson_hsieh 2020-03-02 09:55:26 -0800 Comment on attachment 392074 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392074&action=review >>>> Source/WebCore/platform/graphics/cg/PathCG.cpp:110 >>>> + m_path = CGPathCreateMutableCopy(m_path); >>> >>> It’s *critical* not to release the old path before making the mutable copy. It’s possible that the other owner is no longer retaining the path and so that could be releasing the very last reference to it. >>> >>> This points to another possible optimization, less important but we could do it. If the reference count happens to be 1, then we got lucky and don’t need to make a mutable copy. CFGetRetainCount can be used to check if it’s 1. Although we use CGPathRetain and CGPathRelease we can use CFRetain/CFRelease/CFGetRetainCount. >> >> I think I might be missing something here — without the CGPathRelease here, we’d have a memory leak when a path is copied, and then both the original and copy are mutated. i.e.: >> >> 1. We have a Path a with a +1 CGPathRef p. >> 2. We copy a to another Path b, which +1's CGPathRef p. >> 3. We mutate a, which changes a’s CGPathRef to a new copy, q. >> 4. a is then destroyed, which releases q. q’s retain count is 0 and it is freed. >> 5. b is then destroyed, which releases p. p’s retain count is 1 and it is still alive. >> >> …whereas if we release here, then p would be destroyed in (5) because it is additionally released in (3). >> >> I will add a check to avoid copying when the retain count is 1. > > My point was about the *order* of operations. The code I was reviewing could *destroy* the path by calling CGPathRelease and then call CGPathCreateMutableCopy on the destroyed path. Need to copy *before* releasing in case the retain count is 1. But if you special case the retain count of 1 that is one way of taking care of it. I understand now — thanks for the clarification! The CFGetRetainCount check indeed mitigates this, but I've still shuffled this code around so that we destroy the previous CGPath after copying it. 1624581 8 392074 darin 2020-03-02 09:58:00 -0800 Comment on attachment 392074 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392074&action=review >>> Source/WebCore/platform/graphics/cg/PathCG.cpp:101 >>> +void Path::copyPathBeforeMutationIfNeeded() >> >> We don’t need to add a new function for this. Every call added is right before a call to ensurePlatformPlath, except for Path::transform (see below). While the name doesn’t make this clear, ensurePlatformPath is *always* called just before modifying the path. So this code could be moved inside that function; maybe you want to rename it? > > This sounds good, but I’m not sure what I would rename ensurePlatformPath to since I don’t think it’s good for the details of this optimization to leak into all the call sites of ensurePlatformPath(). > > Maybe something like: > - Rename ensurePlatformPath() to ensureOrCopyPlatformPathIfNeeded() and make it private. > - Add a public ensurePlatformPath() method that just calls ensureOrCopyPlatformPathIfNeeded(). > > Does that sound reasonable? Sounds good. The key is to keep this function name clear and short — a really long name would be irritating. I would be tempted to call it something like mutablePath() rather than using name more like "get ready to modify platform path by copying if needed and return the pointer". I didn’t realize there was a call to ensurePlatformPath for a purpose other than modifying the path. I now see the *single* call outside of PathCG.cpp in the iOS DragDropInteractionState::previewForDragItem, which I had overlooked. All other callers with similar uses call platformPath() and either know it's not empty or check isEmpty(). Would be nice to separate this from all these uses for modifying the path inside the CG path implementation. I now see a design problem in the Path class that we should eventually fix. The "PlatformPathPtr" abstraction is not helping. It makes it impossible to use RetainPtr in Path, but with no abstraction benefit that I can see. For the Cocoa versions of WebKit at least, there are no calls to the platformPath or ensurePlatformPath functions in platform-independent code at all. If we used RetainPtr, it would be a lot harder to get the retain/release wrong in the PathCG implementation. Eventually we would want something like this: public: #if USE(CG) CGPathRef> pathCG() const; <or> RetainPtr<CGPathRef> pathCG() const; // <<< no copy in the name because this just retains for object lifetime safety, doesn’t copy for shared mutability safety >>> #endif private: #if USE(CG) CGMutablePathRef mutablePath(); mutable RetainPtr<CGMutablePathRef> m_path; mutable bool m_shouldCopyPathBeforeMutation { false }; #endif Call sites that wanted to prevent wastefully creating an empty CG path would have to check isEmpty explicitly. Separately, as a clean up step at some point, I it would be slightly better separation of concerns if the platform library provided a function that returned a UIBezierPath. Does not seem like DragDropInteractionState should have to write that code on the spot. This would be analogous to the nsColor function for Color, the NSURL and NSString functions in WTF::URL and WTF::String. Not sure what the best design pattern is, though. Should it be a Path member function? A free function? Which header would we put it in? There seem to be various callers of platformPath that assume it will never be null without calling ensurePlatformPath, such as PlatformCALayerCocoa::setShapePath. 1624582 9 392147 wenson_hsieh 2020-03-02 09:59:02 -0800 Created attachment 392147 v2 1624593 10 392147 darin 2020-03-02 10:06:01 -0800 Comment on attachment 392147 v2 New patch looks good. Aside from possibly doing a wasteful copy in the DragDropInteractionState::previewForDragItem code path, which seems like a minor issue we should not worry about 1624595 11 392147 darin 2020-03-02 10:07:43 -0800 Comment on attachment 392147 v2 New patch looks good. Aside from possibly doing a wasteful copy in the DragDropInteractionState::previewForDragItem code path, which seems like a minor issue we should not worry about 1624700 12 392147 simon.fraser 2020-03-02 13:12:16 -0800 Comment on attachment 392147 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=392147&action=review > Source/WebCore/platform/graphics/cg/PathCG.cpp:98 > + CFRelease(m_path); Weird that we don't use RetainPtr<> here (via some more platform #ifdeffing). > Source/WebCore/platform/graphics/cg/PathCG.cpp:137 > + if (CFGetRetainCount(m_path) > 1) { Ew. > Source/WebCore/platform/graphics/cg/PathCG.cpp:245 > + CFRelease(m_path); CFRelease is not null-safe but I guess isEmpty() checked that. 1624704 13 392147 wenson_hsieh 2020-03-02 13:16:59 -0800 Comment on attachment 392147 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=392147&action=review >> Source/WebCore/platform/graphics/cg/PathCG.cpp:98 >> + CFRelease(m_path); > > Weird that we don't use RetainPtr<> here (via some more platform #ifdeffing). Yes, it’s certainly a strange omission. I will clean this up in the future (and get rid of all the manual CFRelease/CFRetaining). 1624713 14 392147 commit-queue 2020-03-02 13:26:01 -0800 Comment on attachment 392147 v2 Clearing flags on attachment: 392147 Committed r257732: <https://trac.webkit.org/changeset/257732> 1624714 15 commit-queue 2020-03-02 13:26:04 -0800 All reviewed patches have been landed. Closing bug. 1625063 16 392147 darin 2020-03-03 08:38:49 -0800 Comment on attachment 392147 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=392147&action=review > Source/WebCore/platform/graphics/Path.h:219 > + void initializeOrCopyPlatformPathIfNeeded(); I think we should merge this function with ensurePlatformPath. 1625070 17 wenson_hsieh 2020-03-03 08:53:47 -0800 Reopening to attach new patch. 1625071 18 392280 wenson_hsieh 2020-03-03 08:53:47 -0800 Created attachment 392280 Address comment 1625080 19 392280 darin 2020-03-03 09:16:59 -0800 Comment on attachment 392280 Address comment View in context: https://bugs.webkit.org/attachment.cgi?id=392280&action=review I would have used a new bug report for this refinement. Thanks for doing it! > Source/WebCore/platform/graphics/cg/PathCG.cpp:109 > + auto pathToCopy = m_path; > + m_path = CGPathCreateMutableCopy(pathToCopy); > + CFRelease(pathToCopy); This is going to get simpler when we change m_path to a RetainPtr. It will just be: m_path = CGPathCreateMutableCopy(m_path.get()); However in the mean time, I can’t resist pointing out this alternate, insane, one-line way to write it, even though I don’t think you will choose it: CFRelease(std::exchange(m_path, CGPathCreateMutableCopy(m_path))); 1625083 20 392280 wenson_hsieh 2020-03-03 09:22:42 -0800 Comment on attachment 392280 Address comment View in context: https://bugs.webkit.org/attachment.cgi?id=392280&action=review >> Source/WebCore/platform/graphics/cg/PathCG.cpp:109 >> + CFRelease(pathToCopy); > > This is going to get simpler when we change m_path to a RetainPtr. It will just be: > > m_path = CGPathCreateMutableCopy(m_path.get()); > > However in the mean time, I can’t resist pointing out this alternate, insane, one-line way to write it, even though I don’t think you will choose it: > > CFRelease(std::exchange(m_path, CGPathCreateMutableCopy(m_path))); That's...certainly more compact. I suppose there's no harm in going for the one-liner for now; as you mentioned, it'll all be much simpler once I make m_path a RetainPtr, anyways. 1625085 21 392284 wenson_hsieh 2020-03-03 09:26:51 -0800 Created attachment 392284 Address comment 1625149 22 392284 commit-queue 2020-03-03 11:17:43 -0800 Comment on attachment 392284 Address comment Clearing flags on attachment: 392284 Committed r257789: <https://trac.webkit.org/changeset/257789> 1625150 23 commit-queue 2020-03-03 11:17:45 -0800 All reviewed patches have been landed. Closing bug. 392046 2020-02-28 20:50:50 -0800 2020-02-29 15:33:35 -0800 For EWS bug-208265-20200228205050.patch text/plain 9426 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3Njc2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjY2MTk2NTQ2Y2MxMzZm MGZlNTQ1MDUyYmYwZWIzOWM4ZjFjNGYyZi4uMzNkMTY3OGMyNjQ5MzAwMzMwNjllMzZiZWNlOTE3 ZTQ5MTZlMjFjNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ3IEBACisyMDIwLTAyLTI4ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIE1ha2UgUGF0aDo6 UGF0aChjb25zdCBQYXRoJikgYW5kIFBhdGg6Om9wZXJhdG9yPShjb25zdCBQYXRoJikgY2hlYXAK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwODI2NQor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE1ha2UgV2Vi Q29yZTo6UGF0aCdzIGNvcHkgY29uc3RydWN0b3IgYW5kIGNvcHkgYXNzaWdubWVudCBvcGVyYXRv ciBjaGVhcGVyLiBTZWUgYmVsb3cgZm9yIG1vcmUgZGV0YWlsczsgdGhlcmUKKyAgICAgICAgc2hv dWxkIGJlIG5vIG9ic2VydmFibGUgY2hhbmdlIGluIGJlaGF2aW9yLiBUaGlzIGdpdmVzIHVzIGFw cHJveGltYXRlbHkgNiUgYmFjayBvbiB0aGUgY2FudmFzIGxpbmVzIHN1YnRlc3Qgb24KKyAgICAg ICAgTW90aW9uTWFyaywgd2hlbiB0aGUgR1BVIHByb2Nlc3MgaXMgdXNlZCB0byByZW5kZXIgY2Fu dmFzZXMgKHRlc3RlZCBhZ2FpbnN0IG1hY09TIDEwLjE1LjMsIG9uIGEgMTAtY29yZSBpTWFjKS4K KworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL1BhdGguaDoKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y29weVBh dGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6 OmVuc3VyZVBsYXRmb3JtUGF0aCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpQYXRoKToKKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6Om9wZXJhdG9yPSk6CisKKyAgICAgICAgVGhlIGNvcHkgY29u c3RydWN0b3IgYW5kIGNvcHkgYXNzaWdubWVudCBvcGVyYXRvcnMgY3VycmVudGx5IGNhbGwgQ0dQ YXRoQ3JlYXRlTXV0YWJsZUNvcHkgb24gdGhlIGdpdmVuIHBhdGgncworICAgICAgICBwbGF0Zm9y bSBDR1BhdGg7IHRoaXMgaXMgdG8gZW5zdXJlIHRoYXQgaWYgZWl0aGVyIHBhdGggaXMgbXV0YXRl ZCBpbiB0aGUgZnV0dXJlLCB0aGUgbXV0YXRpb24gd29uJ3QgYWxzbyBhZmZlY3QKKyAgICAgICAg dGhlIG90aGVyIGNvcHkgb2YgdGhlIFdlYkNvcmU6OlBhdGguCisKKyAgICAgICAgSG93ZXZlciwg dGhpcyBjYWxsIHRvIENHUGF0aENyZWF0ZU11dGFibGVDb3B5IGlzbid0IG5lZWRlZCBpbiB0aGUg Y2FzZSB3aGVyZSBhIHBhdGggaXMgY29waWVkLCBidXQgbmVpdGhlciBvZgorICAgICAgICB0aGUg cGF0aHMgYXJlIG11dGF0ZWQuIFRvIGF2b2lkIHRoaXMgZXh0cmEgY29weSwgd2UgY2FuIGluc3Rl YWQgaW50cm9kdWNlIGEgZGlydHkgYml0IChtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24pCisgICAg ICAgIHRoYXQgaXMgc2V0IHdoZW4gYSBwYXRoIGlzIGNvcGllZCAoZWl0aGVyIHZpYSB0aGUgY29u c3RydWN0b3IsIG9yIHRocm91Z2ggYXNzaWdubWVudCkgYW5kIHByb2NlZWQgdG8gc2ltcGx5IGNv cHkKKyAgICAgICAgdGhlIHBhdGggcG9pbnRlciB0byB0aGUgbmV3IHBhdGguIE9ubHkgaWYgZWl0 aGVyIHBhdGggaXMgbXV0YXRlZCBkbyB3ZSB0aGVuIGNhbGwgQ0dQYXRoQ3JlYXRlTXV0YWJsZUNv cHkuCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OnRyYW5zZm9ybSk6CisgICAgICAgIChXZWJD b3JlOjpQYXRoOjptb3ZlVG8pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YWRkTGluZVRvKToK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZFF1YWRDdXJ2ZVRvKToKKyAgICAgICAgKFdlYkNv cmU6OlBhdGg6OmFkZEJlemllckN1cnZlVG8pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YWRk QXJjVG8pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6cGxhdGZvcm1BZGRQYXRoRm9yUm91bmRl ZFJlY3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y2xvc2VTdWJwYXRoKToKKyAgICAgICAg KFdlYkNvcmU6OlBhdGg6OmFkZEFyYyk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRSZWN0 KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZEVsbGlwc2UpOgorICAgICAgICAoV2ViQ29y ZTo6UGF0aDo6YWRkUGF0aCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjbGVhcik6CisKKyAg ICAgICAgSW4gYWxsIGNvZGVwYXRocyB0aGF0IG1heSBtdXRhdGUgdGhlIHBhdGgncyBDR011dGFi bGVQYXRoUmVmLCBpZiB0aGUgZGlydHkgYml0IGlzIHNldCwgd2UgbmVlZCB0byBpbnZva2UgdGhl IG5ldworICAgICAgICBoZWxwZXIgbWV0aG9kIGNvcHlQYXRoQmVmb3JlTXV0YXRpb25JZk5lZWRl ZCB0byBtYWtlIHN1cmUgdGhhdCB3ZSBkb24ndCBtdXRhdGUgYSBjb3BpZWQgcGF0aCBlbHNld2hl cmUuCisKIDIwMjAtMDItMjggIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAogICAg ICAgICBHYXJiYWdlIGNvbGxlY3Rpb24gcHJldmVudHMgRm9udEZhY2UubG9hZGVkIHByb21pc2Ug ZnJvbSBnZXR0aW5nIHJlc29sdmVkCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9QYXRoLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRo LmgKaW5kZXggZTVjMmI3YzJiYTVlODg2MTgwNGVjNGVhMzgxOTAxZDJjYTI4NWU3My4uYjdmMTJl M2E4ZDBjNTg1Mjg3NzRhODk1ZWM3ZWE3MDI5OGNjMjMyYiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL1BhdGguaApAQCAtMjE0LDEzICsyMTQsMTUgQEAgcHVibGljOgogICAgIHRl bXBsYXRlPGNsYXNzIERlY29kZXI+IHN0YXRpYyBPcHRpb25hbDxQYXRoPiBkZWNvZGUoRGVjb2Rl ciYpOwogCiBwcml2YXRlOgorICAgIHZvaWQgY29weVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVk KCkgY29uc3Q7CiAjaWYgVVNFKERJUkVDVDJEKQogICAgIFZlY3RvcjxJRDJEMUdlb21ldHJ5Kj4g bV9nZW9tZXRyaWVzOwogICAgIENPTVB0cjxJRDJEMUdlb21ldHJ5R3JvdXA+IG1fcGF0aDsKICAg ICBtdXRhYmxlIENPTVB0cjxJRDJEMUdlb21ldHJ5U2luaz4gbV9hY3RpdmVQYXRoOwogICAgIG11 dGFibGUgYm9vbCBtX2ZpZ3VyZUlzT3BlbmVkIHsgZmFsc2UgfTsKICNlbHNlCi0gICAgUGxhdGZv cm1QYXRoUHRyIG1fcGF0aCB7IG51bGxwdHIgfTsKKyAgICBtdXRhYmxlIFBsYXRmb3JtUGF0aFB0 ciBtX3BhdGggeyBudWxscHRyIH07CisgICAgbXV0YWJsZSBib29sIG1fY29weVBhdGhCZWZvcmVN dXRhdGlvbiB7IGZhbHNlIH07CiAjZW5kaWYKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwCmluZGV4IGY2ZmZjMjI0NGI3MGY0Njg2YjVlNjdl NDNhYWI4ZTQ0ODU4MDBkMmUuLjlkYWU1YWUwNGQ0NThlNzRlZDEzMDExZTRhNDA2YTIxY2EwOWQ4 NjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhD Ry5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNw cApAQCAtOTgsMTYgKzk4LDM2IEBAIFBhdGg6On5QYXRoKCkKICAgICAgICAgQ0dQYXRoUmVsZWFz ZShtX3BhdGgpOwogfQogCit2b2lkIFBhdGg6OmNvcHlQYXRoQmVmb3JlTXV0YXRpb25JZk5lZWRl ZCgpIGNvbnN0Cit7CisgICAgaWYgKCFtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24pCisgICAgICAg IHJldHVybjsKKworICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOworCisgICAg aWYgKG1fcGF0aCkgeworICAgICAgICBDR1BhdGhSZWxlYXNlKG1fcGF0aCk7CisgICAgICAgIG1f cGF0aCA9IENHUGF0aENyZWF0ZU11dGFibGVDb3B5KG1fcGF0aCk7CisgICAgfQorfQorCiBQbGF0 Zm9ybVBhdGhQdHIgUGF0aDo6ZW5zdXJlUGxhdGZvcm1QYXRoKCkKIHsKLSAgICBpZiAoIW1fcGF0 aCkKKyAgICBpZiAoIW1fcGF0aCkgewogICAgICAgICBtX3BhdGggPSBDR1BhdGhDcmVhdGVNdXRh YmxlKCk7CisgICAgICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOworICAgIH0K ICAgICByZXR1cm4gbV9wYXRoOwogfQogCiBQYXRoOjpQYXRoKGNvbnN0IFBhdGgmIG90aGVyKQog ewotICAgIG1fcGF0aCA9IG90aGVyLm1fcGF0aCA/IENHUGF0aENyZWF0ZU11dGFibGVDb3B5KG90 aGVyLm1fcGF0aCkgOiAwOworICAgIG1fcGF0aCA9IG90aGVyLm1fcGF0aDsKKyAgICBpZiAobV9w YXRoKSB7CisgICAgICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IHRydWU7CisgICAgICAg IG90aGVyLm1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IHRydWU7CisgICAgICAgIENHUGF0aFJl dGFpbihtX3BhdGgpOworICAgIH0KIH0KIAogUGF0aDo6UGF0aChQYXRoJiYgb3RoZXIpCkBAIC0x MjIsNyArMTQyLDEyIEBAIFBhdGgmIFBhdGg6Om9wZXJhdG9yPShjb25zdCBQYXRoJiBvdGhlcikK ICAgICAgICAgcmV0dXJuICp0aGlzOwogICAgIGlmIChtX3BhdGgpCiAgICAgICAgIENHUGF0aFJl bGVhc2UobV9wYXRoKTsKLSAgICBtX3BhdGggPSBvdGhlci5tX3BhdGggPyBDR1BhdGhDcmVhdGVN dXRhYmxlQ29weShvdGhlci5tX3BhdGgpIDogbnVsbHB0cjsKKyAgICBtX3BhdGggPSBvdGhlci5t X3BhdGg7CisgICAgaWYgKG1fcGF0aCkgeworICAgICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRp b24gPSB0cnVlOworICAgICAgICBvdGhlci5tX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSB0cnVl OworICAgICAgICBDR1BhdGhSZXRhaW4obV9wYXRoKTsKKyAgICB9CiAgICAgcmV0dXJuICp0aGlz OwogfQogCkBAIC0yMTUsNiArMjQwLDcgQEAgdm9pZCBQYXRoOjp0cmFuc2Zvcm0oY29uc3QgQWZm aW5lVHJhbnNmb3JtJiB0cmFuc2Zvcm0pCiAgICAgaWYgKHRyYW5zZm9ybS5pc0lkZW50aXR5KCkg fHwgaXNFbXB0eSgpKQogICAgICAgICByZXR1cm47CiAKKyAgICBjb3B5UGF0aEJlZm9yZU11dGF0 aW9uSWZOZWVkZWQoKTsKICAgICBDR0FmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm1DRyA9IHRyYW5z Zm9ybTsKICNpZiBQTEFURk9STShXSU4pCiAgICAgQ0dNdXRhYmxlUGF0aFJlZiBwYXRoID0gQ0dQ YXRoQ3JlYXRlTXV0YWJsZSgpOwpAQCAtMjI0LDYgKzI1MCw3IEBAIHZvaWQgUGF0aDo6dHJhbnNm b3JtKGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgdHJhbnNmb3JtKQogI2VuZGlmCiAgICAgQ0dQYXRo UmVsZWFzZShtX3BhdGgpOwogICAgIG1fcGF0aCA9IHBhdGg7CisgICAgbV9jb3B5UGF0aEJlZm9y ZU11dGF0aW9uID0gZmFsc2U7CiB9CiAKIEZsb2F0UmVjdCBQYXRoOjpib3VuZGluZ1JlY3QoKSBj b25zdApAQCAtMjcwLDMxICsyOTcsMzcgQEAgRmxvYXRSZWN0IFBhdGg6OnN0cm9rZUJvdW5kaW5n UmVjdChTdHJva2VTdHlsZUFwcGxpZXIqIGFwcGxpZXIpIGNvbnN0CiAKIHZvaWQgUGF0aDo6bW92 ZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50KQogeworICAgIGNvcHlQYXRoQmVmb3JlTXV0YXRp b25JZk5lZWRlZCgpOwogICAgIENHUGF0aE1vdmVUb1BvaW50KGVuc3VyZVBsYXRmb3JtUGF0aCgp LCBudWxscHRyLCBwb2ludC54KCksIHBvaW50LnkoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkTGlu ZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHApCiB7CisgICAgY29weVBhdGhCZWZvcmVNdXRhdGlvbklm TmVlZGVkKCk7CiAgICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQoZW5zdXJlUGxhdGZvcm1QYXRoKCks IG51bGxwdHIsIHAueCgpLCBwLnkoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkUXVhZEN1cnZlVG8o Y29uc3QgRmxvYXRQb2ludCYgY3AsIGNvbnN0IEZsb2F0UG9pbnQmIHApCiB7CisgICAgY29weVBh dGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7CiAgICAgQ0dQYXRoQWRkUXVhZEN1cnZlVG9Qb2lu dChlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgY3AueCgpLCBjcC55KCksIHAueCgpLCBw LnkoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkQmV6aWVyQ3VydmVUbyhjb25zdCBGbG9hdFBvaW50 JiBjcDEsIGNvbnN0IEZsb2F0UG9pbnQmIGNwMiwgY29uc3QgRmxvYXRQb2ludCYgcCkKIHsKKyAg ICBjb3B5UGF0aEJlZm9yZU11dGF0aW9uSWZOZWVkZWQoKTsKICAgICBDR1BhdGhBZGRDdXJ2ZVRv UG9pbnQoZW5zdXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIsIGNwMS54KCksIGNwMS55KCksIGNw Mi54KCksIGNwMi55KCksIHAueCgpLCBwLnkoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkQXJjVG8o Y29uc3QgRmxvYXRQb2ludCYgcDEsIGNvbnN0IEZsb2F0UG9pbnQmIHAyLCBmbG9hdCByYWRpdXMp CiB7CisgICAgY29weVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7CiAgICAgQ0dQYXRoQWRk QXJjVG9Qb2ludChlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcDEueCgpLCBwMS55KCks IHAyLngoKSwgcDIueSgpLCByYWRpdXMpOwogfQogCiB2b2lkIFBhdGg6OnBsYXRmb3JtQWRkUGF0 aEZvclJvdW5kZWRSZWN0KGNvbnN0IEZsb2F0UmVjdCYgcmVjdCwgY29uc3QgRmxvYXRTaXplJiB0 b3BMZWZ0UmFkaXVzLCBjb25zdCBGbG9hdFNpemUmIHRvcFJpZ2h0UmFkaXVzLCBjb25zdCBGbG9h dFNpemUmIGJvdHRvbUxlZnRSYWRpdXMsIGNvbnN0IEZsb2F0U2l6ZSYgYm90dG9tUmlnaHRSYWRp dXMpCiB7CisgICAgY29weVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7CiAjaWYgUExBVEZP Uk0oQ09DT0EpCiAgICAgYm9vbCBlcXVhbFdpZHRocyA9ICh0b3BMZWZ0UmFkaXVzLndpZHRoKCkg PT0gdG9wUmlnaHRSYWRpdXMud2lkdGgoKSAmJiB0b3BSaWdodFJhZGl1cy53aWR0aCgpID09IGJv dHRvbUxlZnRSYWRpdXMud2lkdGgoKSAmJiBib3R0b21MZWZ0UmFkaXVzLndpZHRoKCkgPT0gYm90 dG9tUmlnaHRSYWRpdXMud2lkdGgoKSk7CiAgICAgYm9vbCBlcXVhbEhlaWdodHMgPSAodG9wTGVm dFJhZGl1cy5oZWlnaHQoKSA9PSBib3R0b21MZWZ0UmFkaXVzLmhlaWdodCgpICYmIGJvdHRvbUxl ZnRSYWRpdXMuaGVpZ2h0KCkgPT0gdG9wUmlnaHRSYWRpdXMuaGVpZ2h0KCkgJiYgdG9wUmlnaHRS YWRpdXMuaGVpZ2h0KCkgPT0gYm90dG9tUmlnaHRSYWRpdXMuaGVpZ2h0KCkpOwpAQCAtMzQ4LDIz ICszODEsMjkgQEAgdm9pZCBQYXRoOjpjbG9zZVN1YnBhdGgoKQogICAgIGlmIChpc051bGwoKSkK ICAgICAgICAgcmV0dXJuOwogCisgICAgY29weVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7 CiAgICAgQ0dQYXRoQ2xvc2VTdWJwYXRoKG1fcGF0aCk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkQXJj KGNvbnN0IEZsb2F0UG9pbnQmIHAsIGZsb2F0IHJhZGl1cywgZmxvYXQgc3RhcnRBbmdsZSwgZmxv YXQgZW5kQW5nbGUsIGJvb2wgY2xvY2t3aXNlKQogewogICAgIC8vIFdvcmthcm91bmQgZm9yIDxy ZGFyOi8vcHJvYmxlbS81MTg5MjMzPiBDR1BhdGhBZGRBcmMgaGFuZ3Mgb3IgY3Jhc2hlcyB3aGVu IHBhc3NlZCBpbmYgYXMgc3RhcnQgb3IgZW5kIGFuZ2xlCi0gICAgaWYgKHN0ZDo6aXNmaW5pdGUo c3RhcnRBbmdsZSkgJiYgc3RkOjppc2Zpbml0ZShlbmRBbmdsZSkpCi0gICAgICAgIENHUGF0aEFk ZEFyYyhlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcC54KCksIHAueSgpLCByYWRpdXMs IHN0YXJ0QW5nbGUsIGVuZEFuZ2xlLCBjbG9ja3dpc2UpOworICAgIGlmICghc3RkOjppc2Zpbml0 ZShzdGFydEFuZ2xlKSB8fCAhc3RkOjppc2Zpbml0ZShlbmRBbmdsZSkpCisgICAgICAgIHJldHVy bjsKKworICAgIGNvcHlQYXRoQmVmb3JlTXV0YXRpb25JZk5lZWRlZCgpOworICAgIENHUGF0aEFk ZEFyYyhlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcC54KCksIHAueSgpLCByYWRpdXMs IHN0YXJ0QW5nbGUsIGVuZEFuZ2xlLCBjbG9ja3dpc2UpOwogfQogCiB2b2lkIFBhdGg6OmFkZFJl Y3QoY29uc3QgRmxvYXRSZWN0JiByKQogeworICAgIGNvcHlQYXRoQmVmb3JlTXV0YXRpb25JZk5l ZWRlZCgpOwogICAgIENHUGF0aEFkZFJlY3QoZW5zdXJlUGxhdGZvcm1QYXRoKCksIDAsIHIpOwog fQogCiB2b2lkIFBhdGg6OmFkZEVsbGlwc2UoRmxvYXRQb2ludCBwLCBmbG9hdCByYWRpdXNYLCBm bG9hdCByYWRpdXNZLCBmbG9hdCByb3RhdGlvbiwgZmxvYXQgc3RhcnRBbmdsZSwgZmxvYXQgZW5k QW5nbGUsIGJvb2wgYW50aWNsb2Nrd2lzZSkKIHsKKyAgICBjb3B5UGF0aEJlZm9yZU11dGF0aW9u SWZOZWVkZWQoKTsKICAgICBBZmZpbmVUcmFuc2Zvcm0gdHJhbnNmb3JtOwogICAgIHRyYW5zZm9y bS50cmFuc2xhdGUocC54KCksIHAueSgpKS5yb3RhdGUocmFkMmRlZyhyb3RhdGlvbikpLnNjYWxl KHJhZGl1c1gsIHJhZGl1c1kpOwogCkBAIC0zNzQsNiArNDEzLDcgQEAgdm9pZCBQYXRoOjphZGRF bGxpcHNlKEZsb2F0UG9pbnQgcCwgZmxvYXQgcmFkaXVzWCwgZmxvYXQgcmFkaXVzWSwgZmxvYXQg cm90YXRpb24KIAogdm9pZCBQYXRoOjphZGRFbGxpcHNlKGNvbnN0IEZsb2F0UmVjdCYgcikKIHsK KyAgICBjb3B5UGF0aEJlZm9yZU11dGF0aW9uSWZOZWVkZWQoKTsKICAgICBDR1BhdGhBZGRFbGxp cHNlSW5SZWN0KGVuc3VyZVBsYXRmb3JtUGF0aCgpLCAwLCByKTsKIH0KIApAQCAtMzg1LDYgKzQy NSw3IEBAIHZvaWQgUGF0aDo6YWRkUGF0aChjb25zdCBQYXRoJiBwYXRoLCBjb25zdCBBZmZpbmVU cmFuc2Zvcm0mIHRyYW5zZm9ybSkKICAgICBpZiAoIXRyYW5zZm9ybS5pc0ludmVydGlibGUoKSkK ICAgICAgICAgcmV0dXJuOwogCisgICAgY29weVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7 CiAgICAgQ0dBZmZpbmVUcmFuc2Zvcm0gdHJhbnNmb3JtQ0cgPSB0cmFuc2Zvcm07CiAgICAgLy8g Q0cgZG9lc24ndCBhbGxvdyBhZGRpbmcgYSBwYXRoIHRvIGl0c2VsZi4gT3B0aW1pemUgZm9yIHRo ZSBjb21tb24gY2FzZQogICAgIC8vIGFuZCBjb3B5IHRoZSBwYXRoIGZvciB0aGUgc2VsZiByZWZl cmVuY2luZyBjYXNlLgpAQCAtNDA1LDYgKzQ0Niw3IEBAIHZvaWQgUGF0aDo6Y2xlYXIoKQogCiAg ICAgQ0dQYXRoUmVsZWFzZShtX3BhdGgpOwogICAgIG1fcGF0aCA9IENHUGF0aENyZWF0ZU11dGFi bGUoKTsKKyAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKIH0KIAogYm9vbCBQ YXRoOjppc0VtcHR5KCkgY29uc3QK 392074 2020-02-29 15:33:36 -0800 2020-03-02 09:59:00 -0800 Patch bug-208265-20200229153335.patch text/plain 9474 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3NjM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTIxYjM3MjI0MDVjZjgy ODk2MDA2YWRlNWM5MDJiOTE5NmU5MTE3ZS4uNDU2NmVhYjdjNDcxYWZjNmMwN2IwMzdiZTdiMDJk NWVkZWEwNDVhZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ3IEBACisyMDIwLTAyLTI4ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIE1ha2UgUGF0aDo6 UGF0aChjb25zdCBQYXRoJikgYW5kIFBhdGg6Om9wZXJhdG9yPShjb25zdCBQYXRoJikgY2hlYXAK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwODI2NQor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE1ha2UgV2Vi Q29yZTo6UGF0aCdzIGNvcHkgY29uc3RydWN0b3IgYW5kIGNvcHkgYXNzaWdubWVudCBvcGVyYXRv ciBjaGVhcGVyLiBTZWUgYmVsb3cgZm9yIG1vcmUgZGV0YWlsczsgdGhlcmUKKyAgICAgICAgc2hv dWxkIGJlIG5vIG9ic2VydmFibGUgY2hhbmdlIGluIGJlaGF2aW9yLiBUaGlzIGdpdmVzIHVzIGFw cHJveGltYXRlbHkgNiUgYmFjayBvbiB0aGUgY2FudmFzIGxpbmVzIHN1YnRlc3Qgb24KKyAgICAg ICAgTW90aW9uTWFyaywgd2hlbiB0aGUgR1BVIHByb2Nlc3MgaXMgdXNlZCB0byByZW5kZXIgY2Fu dmFzZXMgKHRlc3RlZCBhZ2FpbnN0IG1hY09TIDEwLjE1LjMsIG9uIGEgMTAtY29yZSBpTWFjKS4K KworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL1BhdGguaDoKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y29weVBh dGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6 OmVuc3VyZVBsYXRmb3JtUGF0aCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpQYXRoKToKKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6Om9wZXJhdG9yPSk6CisKKyAgICAgICAgVGhlIGNvcHkgY29u c3RydWN0b3IgYW5kIGNvcHkgYXNzaWdubWVudCBvcGVyYXRvcnMgY3VycmVudGx5IGNhbGwgQ0dQ YXRoQ3JlYXRlTXV0YWJsZUNvcHkgb24gdGhlIGdpdmVuIHBhdGgncworICAgICAgICBwbGF0Zm9y bSBDR1BhdGg7IHRoaXMgaXMgdG8gZW5zdXJlIHRoYXQgaWYgZWl0aGVyIHBhdGggaXMgbXV0YXRl ZCBpbiB0aGUgZnV0dXJlLCB0aGUgbXV0YXRpb24gd29uJ3QgYWxzbyBhZmZlY3QKKyAgICAgICAg dGhlIG90aGVyIGNvcHkgb2YgdGhlIFdlYkNvcmU6OlBhdGguCisKKyAgICAgICAgSG93ZXZlciwg dGhpcyBjYWxsIHRvIENHUGF0aENyZWF0ZU11dGFibGVDb3B5IGlzbid0IG5lZWRlZCBpbiB0aGUg Y2FzZSB3aGVyZSBhIHBhdGggaXMgY29waWVkLCBidXQgbmVpdGhlciBvZgorICAgICAgICB0aGUg cGF0aHMgYXJlIG11dGF0ZWQuIFRvIGF2b2lkIHRoaXMgZXh0cmEgY29weSwgd2UgY2FuIGluc3Rl YWQgaW50cm9kdWNlIGEgZGlydHkgYml0IChtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24pCisgICAg ICAgIHRoYXQgaXMgc2V0IHdoZW4gYSBwYXRoIGlzIGNvcGllZCAoZWl0aGVyIHZpYSB0aGUgY29u c3RydWN0b3IsIG9yIHRocm91Z2ggYXNzaWdubWVudCkgYW5kIHByb2NlZWQgdG8gc2ltcGx5IGNv cHkKKyAgICAgICAgdGhlIHBhdGggcG9pbnRlciB0byB0aGUgbmV3IHBhdGguIE9ubHkgaWYgZWl0 aGVyIHBhdGggaXMgbXV0YXRlZCBkbyB3ZSB0aGVuIGNhbGwgQ0dQYXRoQ3JlYXRlTXV0YWJsZUNv cHkuCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OnRyYW5zZm9ybSk6CisgICAgICAgIChXZWJD b3JlOjpQYXRoOjptb3ZlVG8pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YWRkTGluZVRvKToK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZFF1YWRDdXJ2ZVRvKToKKyAgICAgICAgKFdlYkNv cmU6OlBhdGg6OmFkZEJlemllckN1cnZlVG8pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YWRk QXJjVG8pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6cGxhdGZvcm1BZGRQYXRoRm9yUm91bmRl ZFJlY3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y2xvc2VTdWJwYXRoKToKKyAgICAgICAg KFdlYkNvcmU6OlBhdGg6OmFkZEFyYyk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRSZWN0 KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZEVsbGlwc2UpOgorICAgICAgICAoV2ViQ29y ZTo6UGF0aDo6YWRkUGF0aCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjbGVhcik6CisKKyAg ICAgICAgSW4gYWxsIGNvZGVwYXRocyB0aGF0IG1heSBtdXRhdGUgdGhlIHBhdGgncyBDR011dGFi bGVQYXRoUmVmLCBpZiB0aGUgZGlydHkgYml0IGlzIHNldCwgd2UgbmVlZCB0byBpbnZva2UgdGhl IG5ldworICAgICAgICBoZWxwZXIgbWV0aG9kIGNvcHlQYXRoQmVmb3JlTXV0YXRpb25JZk5lZWRl ZCB0byBtYWtlIHN1cmUgdGhhdCB3ZSBkb24ndCBtdXRhdGUgYSBjb3BpZWQgcGF0aCBlbHNld2hl cmUuCisKIDIwMjAtMDItMjggIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+ CiAKICAgICAgICAgQWRkIGFuIGludGVybmFsIHNldHRpbmcgdG8gZW5hYmxlIG9yIGRpc2FibGUg Y2FudmFzIHJlbmRlcmluZyBpbiB0aGUgR1BVIFByb2Nlc3MKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1BhdGguaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL1BhdGguaAppbmRleCBlNWMyYjdjMmJhNWU4ODYxODA0ZWM0ZWEzODE5MDFkMmNh Mjg1ZTczLi4wMTJlNTQ0NTNjZTYwODM0MzBkNWI5Yzg4NjQ3MjI4NjM2ZDVmYTM5IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oCkBAIC0yMTQsMTMgKzIxNCwyMSBAQCBw dWJsaWM6CiAgICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gc3RhdGljIE9wdGlvbmFsPFBhdGg+ IGRlY29kZShEZWNvZGVyJik7CiAKIHByaXZhdGU6CisjaWYgVVNFKENHKQorICAgIHZvaWQgY29w eVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7CisjZW5kaWYKKwogI2lmIFVTRShESVJFQ1Qy RCkKICAgICBWZWN0b3I8SUQyRDFHZW9tZXRyeSo+IG1fZ2VvbWV0cmllczsKICAgICBDT01QdHI8 SUQyRDFHZW9tZXRyeUdyb3VwPiBtX3BhdGg7CiAgICAgbXV0YWJsZSBDT01QdHI8SUQyRDFHZW9t ZXRyeVNpbms+IG1fYWN0aXZlUGF0aDsKICAgICBtdXRhYmxlIGJvb2wgbV9maWd1cmVJc09wZW5l ZCB7IGZhbHNlIH07CiAjZWxzZQotICAgIFBsYXRmb3JtUGF0aFB0ciBtX3BhdGggeyBudWxscHRy IH07CisgICAgbXV0YWJsZSBQbGF0Zm9ybVBhdGhQdHIgbV9wYXRoIHsgbnVsbHB0ciB9OworI2Vu ZGlmCisKKyNpZiBVU0UoQ0cpCisgICAgbXV0YWJsZSBib29sIG1fY29weVBhdGhCZWZvcmVNdXRh dGlvbiB7IGZhbHNlIH07CiAjZW5kaWYKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwCmluZGV4IGY2ZmZjMjI0NGI3MGY0Njg2YjVlNjdlNDNh YWI4ZTQ0ODU4MDBkMmUuLjBiMmJlMmFmNjFhNDRlYmMyMjdjMGQyY2RhNzZmNTA0YjQxNTc3N2Eg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcApA QCAtOTgsMTYgKzk4LDM2IEBAIFBhdGg6On5QYXRoKCkKICAgICAgICAgQ0dQYXRoUmVsZWFzZSht X3BhdGgpOwogfQogCit2b2lkIFBhdGg6OmNvcHlQYXRoQmVmb3JlTXV0YXRpb25JZk5lZWRlZCgp Cit7CisgICAgaWYgKCFtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24pCisgICAgICAgIHJldHVybjsK KworICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOworCisgICAgaWYgKG1fcGF0 aCkgeworICAgICAgICBDR1BhdGhSZWxlYXNlKG1fcGF0aCk7CisgICAgICAgIG1fcGF0aCA9IENH UGF0aENyZWF0ZU11dGFibGVDb3B5KG1fcGF0aCk7CisgICAgfQorfQorCiBQbGF0Zm9ybVBhdGhQ dHIgUGF0aDo6ZW5zdXJlUGxhdGZvcm1QYXRoKCkKIHsKLSAgICBpZiAoIW1fcGF0aCkKKyAgICBp ZiAoIW1fcGF0aCkgewogICAgICAgICBtX3BhdGggPSBDR1BhdGhDcmVhdGVNdXRhYmxlKCk7Cisg ICAgICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOworICAgIH0KICAgICByZXR1 cm4gbV9wYXRoOwogfQogCiBQYXRoOjpQYXRoKGNvbnN0IFBhdGgmIG90aGVyKQogewotICAgIG1f cGF0aCA9IG90aGVyLm1fcGF0aCA/IENHUGF0aENyZWF0ZU11dGFibGVDb3B5KG90aGVyLm1fcGF0 aCkgOiAwOworICAgIG1fcGF0aCA9IG90aGVyLm1fcGF0aDsKKyAgICBpZiAobV9wYXRoKSB7Cisg ICAgICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IHRydWU7CisgICAgICAgIG90aGVyLm1f Y29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IHRydWU7CisgICAgICAgIENHUGF0aFJldGFpbihtX3Bh dGgpOworICAgIH0KIH0KIAogUGF0aDo6UGF0aChQYXRoJiYgb3RoZXIpCkBAIC0xMjIsNyArMTQy LDEyIEBAIFBhdGgmIFBhdGg6Om9wZXJhdG9yPShjb25zdCBQYXRoJiBvdGhlcikKICAgICAgICAg cmV0dXJuICp0aGlzOwogICAgIGlmIChtX3BhdGgpCiAgICAgICAgIENHUGF0aFJlbGVhc2UobV9w YXRoKTsKLSAgICBtX3BhdGggPSBvdGhlci5tX3BhdGggPyBDR1BhdGhDcmVhdGVNdXRhYmxlQ29w eShvdGhlci5tX3BhdGgpIDogbnVsbHB0cjsKKyAgICBtX3BhdGggPSBvdGhlci5tX3BhdGg7Cisg ICAgaWYgKG1fcGF0aCkgeworICAgICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSB0cnVl OworICAgICAgICBvdGhlci5tX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSB0cnVlOworICAgICAg ICBDR1BhdGhSZXRhaW4obV9wYXRoKTsKKyAgICB9CiAgICAgcmV0dXJuICp0aGlzOwogfQogCkBA IC0yMTUsNiArMjQwLDcgQEAgdm9pZCBQYXRoOjp0cmFuc2Zvcm0oY29uc3QgQWZmaW5lVHJhbnNm b3JtJiB0cmFuc2Zvcm0pCiAgICAgaWYgKHRyYW5zZm9ybS5pc0lkZW50aXR5KCkgfHwgaXNFbXB0 eSgpKQogICAgICAgICByZXR1cm47CiAKKyAgICBjb3B5UGF0aEJlZm9yZU11dGF0aW9uSWZOZWVk ZWQoKTsKICAgICBDR0FmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm1DRyA9IHRyYW5zZm9ybTsKICNp ZiBQTEFURk9STShXSU4pCiAgICAgQ0dNdXRhYmxlUGF0aFJlZiBwYXRoID0gQ0dQYXRoQ3JlYXRl TXV0YWJsZSgpOwpAQCAtMjI0LDYgKzI1MCw3IEBAIHZvaWQgUGF0aDo6dHJhbnNmb3JtKGNvbnN0 IEFmZmluZVRyYW5zZm9ybSYgdHJhbnNmb3JtKQogI2VuZGlmCiAgICAgQ0dQYXRoUmVsZWFzZSht X3BhdGgpOwogICAgIG1fcGF0aCA9IHBhdGg7CisgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9u ID0gZmFsc2U7CiB9CiAKIEZsb2F0UmVjdCBQYXRoOjpib3VuZGluZ1JlY3QoKSBjb25zdApAQCAt MjcwLDMxICsyOTcsMzcgQEAgRmxvYXRSZWN0IFBhdGg6OnN0cm9rZUJvdW5kaW5nUmVjdChTdHJv a2VTdHlsZUFwcGxpZXIqIGFwcGxpZXIpIGNvbnN0CiAKIHZvaWQgUGF0aDo6bW92ZVRvKGNvbnN0 IEZsb2F0UG9pbnQmIHBvaW50KQogeworICAgIGNvcHlQYXRoQmVmb3JlTXV0YXRpb25JZk5lZWRl ZCgpOwogICAgIENHUGF0aE1vdmVUb1BvaW50KGVuc3VyZVBsYXRmb3JtUGF0aCgpLCBudWxscHRy LCBwb2ludC54KCksIHBvaW50LnkoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkTGluZVRvKGNvbnN0 IEZsb2F0UG9pbnQmIHApCiB7CisgICAgY29weVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7 CiAgICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQoZW5zdXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIs IHAueCgpLCBwLnkoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkUXVhZEN1cnZlVG8oY29uc3QgRmxv YXRQb2ludCYgY3AsIGNvbnN0IEZsb2F0UG9pbnQmIHApCiB7CisgICAgY29weVBhdGhCZWZvcmVN dXRhdGlvbklmTmVlZGVkKCk7CiAgICAgQ0dQYXRoQWRkUXVhZEN1cnZlVG9Qb2ludChlbnN1cmVQ bGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgY3AueCgpLCBjcC55KCksIHAueCgpLCBwLnkoKSk7CiB9 CiAKIHZvaWQgUGF0aDo6YWRkQmV6aWVyQ3VydmVUbyhjb25zdCBGbG9hdFBvaW50JiBjcDEsIGNv bnN0IEZsb2F0UG9pbnQmIGNwMiwgY29uc3QgRmxvYXRQb2ludCYgcCkKIHsKKyAgICBjb3B5UGF0 aEJlZm9yZU11dGF0aW9uSWZOZWVkZWQoKTsKICAgICBDR1BhdGhBZGRDdXJ2ZVRvUG9pbnQoZW5z dXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIsIGNwMS54KCksIGNwMS55KCksIGNwMi54KCksIGNw Mi55KCksIHAueCgpLCBwLnkoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkQXJjVG8oY29uc3QgRmxv YXRQb2ludCYgcDEsIGNvbnN0IEZsb2F0UG9pbnQmIHAyLCBmbG9hdCByYWRpdXMpCiB7CisgICAg Y29weVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7CiAgICAgQ0dQYXRoQWRkQXJjVG9Qb2lu dChlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcDEueCgpLCBwMS55KCksIHAyLngoKSwg cDIueSgpLCByYWRpdXMpOwogfQogCiB2b2lkIFBhdGg6OnBsYXRmb3JtQWRkUGF0aEZvclJvdW5k ZWRSZWN0KGNvbnN0IEZsb2F0UmVjdCYgcmVjdCwgY29uc3QgRmxvYXRTaXplJiB0b3BMZWZ0UmFk aXVzLCBjb25zdCBGbG9hdFNpemUmIHRvcFJpZ2h0UmFkaXVzLCBjb25zdCBGbG9hdFNpemUmIGJv dHRvbUxlZnRSYWRpdXMsIGNvbnN0IEZsb2F0U2l6ZSYgYm90dG9tUmlnaHRSYWRpdXMpCiB7Cisg ICAgY29weVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7CiAjaWYgUExBVEZPUk0oQ09DT0Ep CiAgICAgYm9vbCBlcXVhbFdpZHRocyA9ICh0b3BMZWZ0UmFkaXVzLndpZHRoKCkgPT0gdG9wUmln aHRSYWRpdXMud2lkdGgoKSAmJiB0b3BSaWdodFJhZGl1cy53aWR0aCgpID09IGJvdHRvbUxlZnRS YWRpdXMud2lkdGgoKSAmJiBib3R0b21MZWZ0UmFkaXVzLndpZHRoKCkgPT0gYm90dG9tUmlnaHRS YWRpdXMud2lkdGgoKSk7CiAgICAgYm9vbCBlcXVhbEhlaWdodHMgPSAodG9wTGVmdFJhZGl1cy5o ZWlnaHQoKSA9PSBib3R0b21MZWZ0UmFkaXVzLmhlaWdodCgpICYmIGJvdHRvbUxlZnRSYWRpdXMu aGVpZ2h0KCkgPT0gdG9wUmlnaHRSYWRpdXMuaGVpZ2h0KCkgJiYgdG9wUmlnaHRSYWRpdXMuaGVp Z2h0KCkgPT0gYm90dG9tUmlnaHRSYWRpdXMuaGVpZ2h0KCkpOwpAQCAtMzQ4LDIzICszODEsMjkg QEAgdm9pZCBQYXRoOjpjbG9zZVN1YnBhdGgoKQogICAgIGlmIChpc051bGwoKSkKICAgICAgICAg cmV0dXJuOwogCisgICAgY29weVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7CiAgICAgQ0dQ YXRoQ2xvc2VTdWJwYXRoKG1fcGF0aCk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkQXJjKGNvbnN0IEZs b2F0UG9pbnQmIHAsIGZsb2F0IHJhZGl1cywgZmxvYXQgc3RhcnRBbmdsZSwgZmxvYXQgZW5kQW5n bGUsIGJvb2wgY2xvY2t3aXNlKQogewogICAgIC8vIFdvcmthcm91bmQgZm9yIDxyZGFyOi8vcHJv YmxlbS81MTg5MjMzPiBDR1BhdGhBZGRBcmMgaGFuZ3Mgb3IgY3Jhc2hlcyB3aGVuIHBhc3NlZCBp bmYgYXMgc3RhcnQgb3IgZW5kIGFuZ2xlCi0gICAgaWYgKHN0ZDo6aXNmaW5pdGUoc3RhcnRBbmds ZSkgJiYgc3RkOjppc2Zpbml0ZShlbmRBbmdsZSkpCi0gICAgICAgIENHUGF0aEFkZEFyYyhlbnN1 cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcC54KCksIHAueSgpLCByYWRpdXMsIHN0YXJ0QW5n bGUsIGVuZEFuZ2xlLCBjbG9ja3dpc2UpOworICAgIGlmICghc3RkOjppc2Zpbml0ZShzdGFydEFu Z2xlKSB8fCAhc3RkOjppc2Zpbml0ZShlbmRBbmdsZSkpCisgICAgICAgIHJldHVybjsKKworICAg IGNvcHlQYXRoQmVmb3JlTXV0YXRpb25JZk5lZWRlZCgpOworICAgIENHUGF0aEFkZEFyYyhlbnN1 cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcC54KCksIHAueSgpLCByYWRpdXMsIHN0YXJ0QW5n bGUsIGVuZEFuZ2xlLCBjbG9ja3dpc2UpOwogfQogCiB2b2lkIFBhdGg6OmFkZFJlY3QoY29uc3Qg RmxvYXRSZWN0JiByKQogeworICAgIGNvcHlQYXRoQmVmb3JlTXV0YXRpb25JZk5lZWRlZCgpOwog ICAgIENHUGF0aEFkZFJlY3QoZW5zdXJlUGxhdGZvcm1QYXRoKCksIDAsIHIpOwogfQogCiB2b2lk IFBhdGg6OmFkZEVsbGlwc2UoRmxvYXRQb2ludCBwLCBmbG9hdCByYWRpdXNYLCBmbG9hdCByYWRp dXNZLCBmbG9hdCByb3RhdGlvbiwgZmxvYXQgc3RhcnRBbmdsZSwgZmxvYXQgZW5kQW5nbGUsIGJv b2wgYW50aWNsb2Nrd2lzZSkKIHsKKyAgICBjb3B5UGF0aEJlZm9yZU11dGF0aW9uSWZOZWVkZWQo KTsKICAgICBBZmZpbmVUcmFuc2Zvcm0gdHJhbnNmb3JtOwogICAgIHRyYW5zZm9ybS50cmFuc2xh dGUocC54KCksIHAueSgpKS5yb3RhdGUocmFkMmRlZyhyb3RhdGlvbikpLnNjYWxlKHJhZGl1c1gs IHJhZGl1c1kpOwogCkBAIC0zNzQsNiArNDEzLDcgQEAgdm9pZCBQYXRoOjphZGRFbGxpcHNlKEZs b2F0UG9pbnQgcCwgZmxvYXQgcmFkaXVzWCwgZmxvYXQgcmFkaXVzWSwgZmxvYXQgcm90YXRpb24K IAogdm9pZCBQYXRoOjphZGRFbGxpcHNlKGNvbnN0IEZsb2F0UmVjdCYgcikKIHsKKyAgICBjb3B5 UGF0aEJlZm9yZU11dGF0aW9uSWZOZWVkZWQoKTsKICAgICBDR1BhdGhBZGRFbGxpcHNlSW5SZWN0 KGVuc3VyZVBsYXRmb3JtUGF0aCgpLCAwLCByKTsKIH0KIApAQCAtMzg1LDYgKzQyNSw3IEBAIHZv aWQgUGF0aDo6YWRkUGF0aChjb25zdCBQYXRoJiBwYXRoLCBjb25zdCBBZmZpbmVUcmFuc2Zvcm0m IHRyYW5zZm9ybSkKICAgICBpZiAoIXRyYW5zZm9ybS5pc0ludmVydGlibGUoKSkKICAgICAgICAg cmV0dXJuOwogCisgICAgY29weVBhdGhCZWZvcmVNdXRhdGlvbklmTmVlZGVkKCk7CiAgICAgQ0dB ZmZpbmVUcmFuc2Zvcm0gdHJhbnNmb3JtQ0cgPSB0cmFuc2Zvcm07CiAgICAgLy8gQ0cgZG9lc24n dCBhbGxvdyBhZGRpbmcgYSBwYXRoIHRvIGl0c2VsZi4gT3B0aW1pemUgZm9yIHRoZSBjb21tb24g Y2FzZQogICAgIC8vIGFuZCBjb3B5IHRoZSBwYXRoIGZvciB0aGUgc2VsZiByZWZlcmVuY2luZyBj YXNlLgpAQCAtNDA1LDYgKzQ0Niw3IEBAIHZvaWQgUGF0aDo6Y2xlYXIoKQogCiAgICAgQ0dQYXRo UmVsZWFzZShtX3BhdGgpOwogICAgIG1fcGF0aCA9IENHUGF0aENyZWF0ZU11dGFibGUoKTsKKyAg ICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKIH0KIAogYm9vbCBQYXRoOjppc0Vt cHR5KCkgY29uc3QK 392147 2020-03-02 09:59:02 -0800 2020-03-03 09:26:50 -0800 v2 bug-208265-20200302095901.patch text/plain 7784 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3NzE0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTdlOTMxZDc5ZWE3NDhk NDZiNWRjM2Q4YzIwYTljZjNiYTM2MjRmZS4uYjI2ZWQzNDkwNGUxNTBmNDMxNjk2YmU0ZGM0Yzkw ZmVhMWU3MzE2MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ5IEBACisyMDIwLTAzLTAyICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIE1ha2UgUGF0aDo6 UGF0aChjb25zdCBQYXRoJikgYW5kIFBhdGg6Om9wZXJhdG9yPShjb25zdCBQYXRoJikgY2hlYXAK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwODI2NQor ICAgICAgICA8cmRhcjovL3Byb2JsZW0vNTk5MjI0NTI+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFrZSBXZWJDb3JlOjpQYXRoJ3MgY29weSBjb25z dHJ1Y3RvciBhbmQgY29weSBhc3NpZ25tZW50IG9wZXJhdG9yIGNoZWFwZXIuIFNlZSBiZWxvdyBm b3IgbW9yZSBkZXRhaWxzOyB0aGVyZQorICAgICAgICBzaG91bGQgYmUgbm8gb2JzZXJ2YWJsZSBj aGFuZ2UgaW4gYmVoYXZpb3IuIFRoaXMgZ2l2ZXMgdXMgYXBwcm94aW1hdGVseSA2JSBiYWNrIG9u IHRoZSBjYW52YXMgbGluZXMgc3VidGVzdCBvbgorICAgICAgICBNb3Rpb25NYXJrLCB3aGVuIHRo ZSBHUFUgcHJvY2VzcyBpcyB1c2VkIHRvIHJlbmRlciBjYW52YXNlcyAodGVzdGVkIGFnYWluc3Qg bWFjT1MgMTAuMTUuMywgb24gYSAxMC1jb3JlIGlNYWMpLgorCisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvUGF0aC5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5j cHA6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjp+UGF0aCk6CisgICAgICAgIChXZWJDb3JlOjpQ YXRoOjplbnN1cmVQbGF0Zm9ybVBhdGgpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6UGF0aCk6 CisKKyAgICAgICAgVXBkYXRlIG1vdmUgY29uc3RydWN0b3JzIHRvIHNldCBtX2NvcHlQYXRoQmVm b3JlTXV0YXRpb24gdG8gZmFsc2Ugb24gdGhlIGdpdmVuIChtb3ZlZCkgcGF0aC4KKworICAgICAg ICAoV2ViQ29yZTo6UGF0aDo6c3dhcCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjppbml0aWFs aXplT3JDb3B5UGxhdGZvcm1QYXRoSWZOZWVkZWQpOgorCisgICAgICAgIFdoZW5ldmVyIHdlIG5l ZWQgdG8gZW5zdXJlIHRoZSBwbGF0Zm9ybSBDR1BhdGggKGkuZS4gcHJpb3IgdG8gYXBwZW5kaW5n IHRvIGl0KSwgY2hlY2sgdGhlIG5ldyBmbGFnIHRvIHNlZQorICAgICAgICB3aGV0aGVyIGl0J3Mg bmVjZXNzYXJ5IHRvIGFwcGx5IHRoZSBzdWJzZXF1ZW50IG11dGF0aW9uIG9uIGEgY29weSBvZiBt X3BhdGgsIHJhdGhlciB0aGFuIG1fcGF0aCBpdHNlbGYuIFRoZQorICAgICAgICBleGNlcHRpb24g dG8gdGhpcyBpcyB3aGVuIG1fcGF0aCBvbmx5IGhhcyBhIHJldGFpbiBjb3VudCBvZiAxLCB3aGlj aCBpbXBsaWVzIHRoYXQgYWxsIG90aGVyIGNvcGllcyBvZiB0aGlzIHBhdGgKKyAgICAgICAgaGF2 ZSBiZWVuIG11dGF0ZWQgKGFuZCBoYXZlIGNvcGllZCB0aGVpciBwbGF0Zm9ybSBDR1BhdGggYXMg YSByZXN1bHQpOyB0aGlzIG1lYW5zIGl0J3Mgc2FmZSB0byBhcHBseSBjaGFuZ2VzIHRvCisgICAg ICAgIG1fcGF0aCwgc2luY2UgdGhpcyBwYXRoIGlzIG5vdyB0aGUgc29sZSBvd25lciBvZiB0aGUg Q0dQYXRoLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpvcGVyYXRvcj0pOgorCisgICAgICAg IFRoZSBjb3B5IGNvbnN0cnVjdG9yIGFuZCBjb3B5IGFzc2lnbm1lbnQgb3BlcmF0b3JzIGN1cnJl bnRseSBjYWxsIENHUGF0aENyZWF0ZU11dGFibGVDb3B5IG9uIHRoZSBnaXZlbiBwYXRoJ3MKKyAg ICAgICAgcGxhdGZvcm0gQ0dQYXRoOyB0aGlzIGlzIHRvIGVuc3VyZSB0aGF0IGlmIGVpdGhlciBw YXRoIGlzIG11dGF0ZWQgaW4gdGhlIGZ1dHVyZSwgdGhlIG11dGF0aW9uIHdvbid0IGFsc28gYWZm ZWN0CisgICAgICAgIHRoZSBvdGhlciBjb3B5IG9mIHRoZSBXZWJDb3JlOjpQYXRoLgorCisgICAg ICAgIEhvd2V2ZXIsIHRoaXMgY2FsbCB0byBDR1BhdGhDcmVhdGVNdXRhYmxlQ29weSBpc24ndCBu ZWVkZWQgaW4gdGhlIGNhc2Ugd2hlcmUgYSBwYXRoIGlzIGNvcGllZCwgYnV0IG5laXRoZXIgb2YK KyAgICAgICAgdGhlIHBhdGhzIGFyZSBtdXRhdGVkLiBUbyBhdm9pZCB0aGlzIGV4dHJhIGNvcHks IHdlIGNhbiBpbnN0ZWFkIGludHJvZHVjZSBhIGRpcnR5IGJpdCAobV9jb3B5UGF0aEJlZm9yZU11 dGF0aW9uKQorICAgICAgICB0aGF0IGlzIHNldCB3aGVuIGEgcGF0aCBpcyBjb3BpZWQgKGVpdGhl ciB2aWEgdGhlIGNvbnN0cnVjdG9yLCBvciB0aHJvdWdoIGFzc2lnbm1lbnQpIGFuZCBwcm9jZWVk IHRvIHNpbXBseSBjb3B5CisgICAgICAgIHRoZSBwYXRoIHBvaW50ZXIgdG8gdGhlIG5ldyBwYXRo LiBPbmx5IGlmIGVpdGhlciBwYXRoIGlzIG11dGF0ZWQgZG8gd2UgdGhlbiBjYWxsIENHUGF0aENy ZWF0ZU11dGFibGVDb3B5LgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjp0cmFuc2Zvcm0pOgor ICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y2xvc2VTdWJwYXRoKToKKyAgICAgICAgKFdlYkNvcmU6 OlBhdGg6OmFkZEFyYyk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRQYXRoKToKKyAgICAg ICAgKFdlYkNvcmU6OlBhdGg6OmNsZWFyKToKKwogMjAyMC0wMy0wMiAgQ2hyaXMgRHVtZXogIDxj ZHVtZXpAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBxdWlyayB0byBkaXNhYmxlIHRvIGJhY2sv Zm9yd2FyZCBjYWNoZSBvbiBkb2NzLmdvb2dsZS5jb20KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL1BhdGguaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL1BhdGguaAppbmRleCBlNWMyYjdjMmJhNWU4ODYxODA0ZWM0ZWEzODE5MDFkMmNhMjg1 ZTczLi4yZWM1NmU3MGY0ZDA5YmNiZGQ3NzVjYzcwYWRhNzNmMzliM2RiOTk5IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oCkBAIC0yMTQsMTMgKzIxNCwyMiBAQCBwdWJs aWM6CiAgICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gc3RhdGljIE9wdGlvbmFsPFBhdGg+IGRl Y29kZShEZWNvZGVyJik7CiAKIHByaXZhdGU6CisjaWYgVVNFKENHKQorICAgIHZvaWQgc3dhcChQ YXRoJik7CisgICAgdm9pZCBpbml0aWFsaXplT3JDb3B5UGxhdGZvcm1QYXRoSWZOZWVkZWQoKTsK KyNlbmRpZgorCiAjaWYgVVNFKERJUkVDVDJEKQogICAgIFZlY3RvcjxJRDJEMUdlb21ldHJ5Kj4g bV9nZW9tZXRyaWVzOwogICAgIENPTVB0cjxJRDJEMUdlb21ldHJ5R3JvdXA+IG1fcGF0aDsKICAg ICBtdXRhYmxlIENPTVB0cjxJRDJEMUdlb21ldHJ5U2luaz4gbV9hY3RpdmVQYXRoOwogICAgIG11 dGFibGUgYm9vbCBtX2ZpZ3VyZUlzT3BlbmVkIHsgZmFsc2UgfTsKICNlbHNlCi0gICAgUGxhdGZv cm1QYXRoUHRyIG1fcGF0aCB7IG51bGxwdHIgfTsKKyAgICBtdXRhYmxlIFBsYXRmb3JtUGF0aFB0 ciBtX3BhdGggeyBudWxscHRyIH07CisjZW5kaWYKKworI2lmIFVTRShDRykKKyAgICBtdXRhYmxl IGJvb2wgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uIHsgZmFsc2UgfTsKICNlbmRpZgogfTsKIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAKaW5kZXgg ZjZmZmMyMjQ0YjcwZjQ2ODZiNWU2N2U0M2FhYjhlNDQ4NTgwMGQyZS4uNTdkMzRhOTEzZjQ5ZWY1 MmNmNDlmOTY4NjI2ZWMwYTc3ZjIyZjA0YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwCkBAIC05NSw0NSArOTUsNjUgQEAgUGF0aDo6UGF0aChS ZXRhaW5QdHI8Q0dNdXRhYmxlUGF0aFJlZj4gcCkKIFBhdGg6On5QYXRoKCkKIHsKICAgICBpZiAo bV9wYXRoKQotICAgICAgICBDR1BhdGhSZWxlYXNlKG1fcGF0aCk7CisgICAgICAgIENGUmVsZWFz ZShtX3BhdGgpOwogfQogCiBQbGF0Zm9ybVBhdGhQdHIgUGF0aDo6ZW5zdXJlUGxhdGZvcm1QYXRo KCkKIHsKLSAgICBpZiAoIW1fcGF0aCkKLSAgICAgICAgbV9wYXRoID0gQ0dQYXRoQ3JlYXRlTXV0 YWJsZSgpOworICAgIGluaXRpYWxpemVPckNvcHlQbGF0Zm9ybVBhdGhJZk5lZWRlZCgpOwogICAg IHJldHVybiBtX3BhdGg7CiB9CiAKIFBhdGg6OlBhdGgoY29uc3QgUGF0aCYgb3RoZXIpCiB7Ci0g ICAgbV9wYXRoID0gb3RoZXIubV9wYXRoID8gQ0dQYXRoQ3JlYXRlTXV0YWJsZUNvcHkob3RoZXIu bV9wYXRoKSA6IDA7CisgICAgbV9wYXRoID0geyBvdGhlci5tX3BhdGggfTsKKyAgICBpZiAobV9w YXRoKSB7CisgICAgICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IHRydWU7CisgICAgICAg IG90aGVyLm1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IHRydWU7CisgICAgICAgIENGUmV0YWlu KG1fcGF0aCk7CisgICAgfQogfQogCiBQYXRoOjpQYXRoKFBhdGgmJiBvdGhlcikKKyAgICA6IG1f cGF0aChzdGQ6OmV4Y2hhbmdlKG90aGVyLm1fcGF0aCwgbnVsbHB0cikpCisgICAgLCBtX2NvcHlQ YXRoQmVmb3JlTXV0YXRpb24oc3RkOjpleGNoYW5nZShvdGhlci5tX2NvcHlQYXRoQmVmb3JlTXV0 YXRpb24sIGZhbHNlKSkKIHsKLSAgICBtX3BhdGggPSBvdGhlci5tX3BhdGg7Ci0gICAgb3RoZXIu bV9wYXRoID0gbnVsbHB0cjsKIH0KLSAgICAKKwordm9pZCBQYXRoOjpzd2FwKFBhdGgmIG90aGVy UGF0aCkKK3sKKyAgICBzdGQ6OnN3YXAobV9wYXRoLCBvdGhlclBhdGgubV9wYXRoKTsKKyAgICBz dGQ6OnN3YXAobV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uLCBvdGhlclBhdGgubV9jb3B5UGF0aEJl Zm9yZU11dGF0aW9uKTsKK30KKwordm9pZCBQYXRoOjppbml0aWFsaXplT3JDb3B5UGxhdGZvcm1Q YXRoSWZOZWVkZWQoKQoreworICAgIGlmICghbV9wYXRoKSB7CisgICAgICAgIG1fcGF0aCA9IENH UGF0aENyZWF0ZU11dGFibGUoKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGlmICht X2NvcHlQYXRoQmVmb3JlTXV0YXRpb24pIHsKKyAgICAgICAgaWYgKENGR2V0UmV0YWluQ291bnQo bV9wYXRoKSA+IDEpIHsKKyAgICAgICAgICAgIGF1dG8gcGF0aFRvQ29weSA9IG1fcGF0aDsKKyAg ICAgICAgICAgIG1fcGF0aCA9IENHUGF0aENyZWF0ZU11dGFibGVDb3B5KHBhdGhUb0NvcHkpOwor ICAgICAgICAgICAgQ0ZSZWxlYXNlKHBhdGhUb0NvcHkpOworICAgICAgICB9CisgICAgICAgIG1f Y29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOworICAgIH0KK30KKwogUGF0aCYgUGF0aDo6 b3BlcmF0b3I9KGNvbnN0IFBhdGgmIG90aGVyKQogewotICAgIGlmICh0aGlzID09ICZvdGhlcikK LSAgICAgICAgcmV0dXJuICp0aGlzOwotICAgIGlmIChtX3BhdGgpCi0gICAgICAgIENHUGF0aFJl bGVhc2UobV9wYXRoKTsKLSAgICBtX3BhdGggPSBvdGhlci5tX3BhdGggPyBDR1BhdGhDcmVhdGVN dXRhYmxlQ29weShvdGhlci5tX3BhdGgpIDogbnVsbHB0cjsKKyAgICBQYXRoIGNvcHkgeyBvdGhl ciB9OworICAgIHN3YXAoY29weSk7CiAgICAgcmV0dXJuICp0aGlzOwogfQogCiBQYXRoJiBQYXRo OjpvcGVyYXRvcj0oUGF0aCYmIG90aGVyKQogewotICAgIGlmICh0aGlzID09ICZvdGhlcikKLSAg ICAgICAgcmV0dXJuICp0aGlzOwotICAgIGlmIChtX3BhdGgpCi0gICAgICAgIENHUGF0aFJlbGVh c2UobV9wYXRoKTsKLSAgICBtX3BhdGggPSBvdGhlci5tX3BhdGg7Ci0gICAgb3RoZXIubV9wYXRo ID0gbnVsbHB0cjsKKyAgICBQYXRoIGNvcHkgeyBXVEZNb3ZlKG90aGVyKSB9OworICAgIHN3YXAo Y29weSk7CiAgICAgcmV0dXJuICp0aGlzOwogfQogCkBAIC0yMjIsOCArMjQyLDkgQEAgdm9pZCBQ YXRoOjp0cmFuc2Zvcm0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJiB0cmFuc2Zvcm0pCiAjZWxzZQog ICAgIENHTXV0YWJsZVBhdGhSZWYgcGF0aCA9IENHUGF0aENyZWF0ZU11dGFibGVDb3B5QnlUcmFu c2Zvcm1pbmdQYXRoKG1fcGF0aCwgJnRyYW5zZm9ybUNHKTsKICNlbmRpZgotICAgIENHUGF0aFJl bGVhc2UobV9wYXRoKTsKKyAgICBDRlJlbGVhc2UobV9wYXRoKTsKICAgICBtX3BhdGggPSBwYXRo OworICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOwogfQogCiBGbG9hdFJlY3Qg UGF0aDo6Ym91bmRpbmdSZWN0KCkgY29uc3QKQEAgLTM0OCwxNCArMzY5LDE2IEBAIHZvaWQgUGF0 aDo6Y2xvc2VTdWJwYXRoKCkKICAgICBpZiAoaXNOdWxsKCkpCiAgICAgICAgIHJldHVybjsKIAot ICAgIENHUGF0aENsb3NlU3VicGF0aChtX3BhdGgpOworICAgIENHUGF0aENsb3NlU3VicGF0aChl bnN1cmVQbGF0Zm9ybVBhdGgoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkQXJjKGNvbnN0IEZsb2F0 UG9pbnQmIHAsIGZsb2F0IHJhZGl1cywgZmxvYXQgc3RhcnRBbmdsZSwgZmxvYXQgZW5kQW5nbGUs IGJvb2wgY2xvY2t3aXNlKQogewogICAgIC8vIFdvcmthcm91bmQgZm9yIDxyZGFyOi8vcHJvYmxl bS81MTg5MjMzPiBDR1BhdGhBZGRBcmMgaGFuZ3Mgb3IgY3Jhc2hlcyB3aGVuIHBhc3NlZCBpbmYg YXMgc3RhcnQgb3IgZW5kIGFuZ2xlCi0gICAgaWYgKHN0ZDo6aXNmaW5pdGUoc3RhcnRBbmdsZSkg JiYgc3RkOjppc2Zpbml0ZShlbmRBbmdsZSkpCi0gICAgICAgIENHUGF0aEFkZEFyYyhlbnN1cmVQ bGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcC54KCksIHAueSgpLCByYWRpdXMsIHN0YXJ0QW5nbGUs IGVuZEFuZ2xlLCBjbG9ja3dpc2UpOworICAgIGlmICghc3RkOjppc2Zpbml0ZShzdGFydEFuZ2xl KSB8fCAhc3RkOjppc2Zpbml0ZShlbmRBbmdsZSkpCisgICAgICAgIHJldHVybjsKKworICAgIENH UGF0aEFkZEFyYyhlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcC54KCksIHAueSgpLCBy YWRpdXMsIHN0YXJ0QW5nbGUsIGVuZEFuZ2xlLCBjbG9ja3dpc2UpOwogfQogCiB2b2lkIFBhdGg6 OmFkZFJlY3QoY29uc3QgRmxvYXRSZWN0JiByKQpAQCAtMzk0LDE3ICs0MTcsMTcgQEAgdm9pZCBQ YXRoOjphZGRQYXRoKGNvbnN0IFBhdGgmIHBhdGgsIGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgdHJh bnNmb3JtKQogICAgIH0KICAgICBDR1BhdGhSZWYgcGF0aENvcHkgPSBDR1BhdGhDcmVhdGVDb3B5 KHBhdGgucGxhdGZvcm1QYXRoKCkpOwogICAgIENHUGF0aEFkZFBhdGgoZW5zdXJlUGxhdGZvcm1Q YXRoKCksICZ0cmFuc2Zvcm1DRywgcGF0aENvcHkpOwotICAgIENHUGF0aFJlbGVhc2UocGF0aENv cHkpOworICAgIENGUmVsZWFzZShwYXRoQ29weSk7CiB9CiAKLQogdm9pZCBQYXRoOjpjbGVhcigp CiB7CiAgICAgaWYgKGlzTnVsbCgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBDR1BhdGhSZWxl YXNlKG1fcGF0aCk7CisgICAgQ0ZSZWxlYXNlKG1fcGF0aCk7CiAgICAgbV9wYXRoID0gQ0dQYXRo Q3JlYXRlTXV0YWJsZSgpOworICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOwog fQogCiBib29sIFBhdGg6OmlzRW1wdHkoKSBjb25zdAo= 392280 2020-03-03 08:53:47 -0800 2020-03-03 09:24:42 -0800 Address comment bug-208265-20200303085347.patch text/plain 2815 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3Nzc5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNGI4MmMyZGZiYTRmZjg2 N2Y3NTZlYjU3Njc5NjM0ZTc3YjliN2RmZS4uMzNkNTlmNDM5MjExMzExNWM4ZTY5ZDM5MmNhM2E1 YWQ5YjY0NGJlOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDIwLTAzLTAzICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIEFkZHJlc3MgcG9z dC1jb21taXQgZmVlZGJhY2sgYWZ0ZXIgcjI1NzczMgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA4MjY1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgUmVtb3ZlIHRoZSBwcml2YXRlIGluaXRpYWxpemVPckNv cHlQbGF0Zm9ybVBhdGhJZk5lZWRlZCgpIGhlbHBlciwKKyAgICAgICAgYW5kIG1vdmUgaXRzIGxv Z2ljIGludG8gZW5zdXJlUGxhdGZvcm1QYXRoKCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9QYXRoLmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0aCk6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjppbml0aWFsaXplT3JDb3B5UGxhdGZvcm1QYXRoSWZOZWVkZWQpOiBEZWxl dGVkLgorCiAyMDIwLTAzLTAzICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlh LmNvbT4KIAogICAgICAgICBbR1RLXVtXUEVdIEZpeCBjdXJyZW50IHRpbWUgYW5kIGR1cmF0aW9u IGZvcm1hdHRpbmcgaW4gbWVkaWEgY29udHJvbHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL1BhdGguaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL1BhdGguaAppbmRleCAyZWM1NmU3MGY0ZDA5YmNiZGQ3NzVjYzcwYWRhNzNmMzliM2RiOTk5 Li5jY2Q4YzkzMGZhYmViMjc5MDIzYmEzODM4ZTNiOGRkZjFjNDQxZTMzIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oCkBAIC0yMTYsNyArMjE2LDYgQEAgcHVibGljOgog cHJpdmF0ZToKICNpZiBVU0UoQ0cpCiAgICAgdm9pZCBzd2FwKFBhdGgmKTsKLSAgICB2b2lkIGlu aXRpYWxpemVPckNvcHlQbGF0Zm9ybVBhdGhJZk5lZWRlZCgpOwogI2VuZGlmCiAKICNpZiBVU0Uo RElSRUNUMkQpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j Zy9QYXRoQ0cuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENH LmNwcAppbmRleCA1N2QzNGE5MTNmNDllZjUyY2Y0OWY5Njg2MjZlYzBhNzdmMjJmMDRhLi5hOGFi MWU0ZmQ1YWZmZTM5ZTc3OTdhY2Y5ZDRmZTU4NzZhMDYyNWY1IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAKQEAgLTEwMCw3ICsxMDAsMTYgQEAg UGF0aDo6flBhdGgoKQogCiBQbGF0Zm9ybVBhdGhQdHIgUGF0aDo6ZW5zdXJlUGxhdGZvcm1QYXRo KCkKIHsKLSAgICBpbml0aWFsaXplT3JDb3B5UGxhdGZvcm1QYXRoSWZOZWVkZWQoKTsKKyAgICBp ZiAoIW1fcGF0aCkKKyAgICAgICAgbV9wYXRoID0gQ0dQYXRoQ3JlYXRlTXV0YWJsZSgpOworICAg IGVsc2UgaWYgKG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbikgeworICAgICAgICBpZiAoQ0ZHZXRS ZXRhaW5Db3VudChtX3BhdGgpID4gMSkgeworICAgICAgICAgICAgYXV0byBwYXRoVG9Db3B5ID0g bV9wYXRoOworICAgICAgICAgICAgbV9wYXRoID0gQ0dQYXRoQ3JlYXRlTXV0YWJsZUNvcHkocGF0 aFRvQ29weSk7CisgICAgICAgICAgICBDRlJlbGVhc2UocGF0aFRvQ29weSk7CisgICAgICAgIH0K KyAgICAgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uID0gZmFsc2U7CisgICAgfQogICAgIHJl dHVybiBtX3BhdGg7CiB9CiAKQEAgLTEyNiwyMyArMTM1LDYgQEAgdm9pZCBQYXRoOjpzd2FwKFBh dGgmIG90aGVyUGF0aCkKICAgICBzdGQ6OnN3YXAobV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uLCBv dGhlclBhdGgubV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uKTsKIH0KIAotdm9pZCBQYXRoOjppbml0 aWFsaXplT3JDb3B5UGxhdGZvcm1QYXRoSWZOZWVkZWQoKQotewotICAgIGlmICghbV9wYXRoKSB7 Ci0gICAgICAgIG1fcGF0aCA9IENHUGF0aENyZWF0ZU11dGFibGUoKTsKLSAgICAgICAgcmV0dXJu OwotICAgIH0KLQotICAgIGlmIChtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24pIHsKLSAgICAgICAg aWYgKENGR2V0UmV0YWluQ291bnQobV9wYXRoKSA+IDEpIHsKLSAgICAgICAgICAgIGF1dG8gcGF0 aFRvQ29weSA9IG1fcGF0aDsKLSAgICAgICAgICAgIG1fcGF0aCA9IENHUGF0aENyZWF0ZU11dGFi bGVDb3B5KHBhdGhUb0NvcHkpOwotICAgICAgICAgICAgQ0ZSZWxlYXNlKHBhdGhUb0NvcHkpOwot ICAgICAgICB9Ci0gICAgICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOwotICAg IH0KLX0KLQogUGF0aCYgUGF0aDo6b3BlcmF0b3I9KGNvbnN0IFBhdGgmIG90aGVyKQogewogICAg IFBhdGggY29weSB7IG90aGVyIH07Cg== 392284 2020-03-03 09:26:51 -0800 2020-03-03 11:17:43 -0800 Address comment bug-208265-20200303092650.patch text/plain 2745 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3Nzc5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNGI4MmMyZGZiYTRmZjg2 N2Y3NTZlYjU3Njc5NjM0ZTc3YjliN2RmZS4uZmExYzRlMGM3NGE5MjFkNTA3NmU0NDZmOWM0OGUx NmFjMTBiNThlMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDIwLTAzLTAzICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIEFkZHJlc3MgcG9z dC1jb21taXQgZmVlZGJhY2sgYWZ0ZXIgcjI1NzczMgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA4MjY1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFy aW4gQWRsZXIuCisKKyAgICAgICAgUmVtb3ZlIHRoZSBwcml2YXRlIGluaXRpYWxpemVPckNvcHlQ bGF0Zm9ybVBhdGhJZk5lZWRlZCgpIGhlbHBlciwKKyAgICAgICAgYW5kIG1vdmUgaXRzIGxvZ2lj IGludG8gZW5zdXJlUGxhdGZvcm1QYXRoKCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGlj cy9QYXRoLmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0aCk6CisgICAgICAgIChXZWJD b3JlOjpQYXRoOjppbml0aWFsaXplT3JDb3B5UGxhdGZvcm1QYXRoSWZOZWVkZWQpOiBEZWxldGVk LgorCiAyMDIwLTAzLTAzICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNv bT4KIAogICAgICAgICBbR1RLXVtXUEVdIEZpeCBjdXJyZW50IHRpbWUgYW5kIGR1cmF0aW9uIGZv cm1hdHRpbmcgaW4gbWVkaWEgY29udHJvbHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL1BhdGguaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L1BhdGguaAppbmRleCAyZWM1NmU3MGY0ZDA5YmNiZGQ3NzVjYzcwYWRhNzNmMzliM2RiOTk5Li5j Y2Q4YzkzMGZhYmViMjc5MDIzYmEzODM4ZTNiOGRkZjFjNDQxZTMzIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oCkBAIC0yMTYsNyArMjE2LDYgQEAgcHVibGljOgogcHJp dmF0ZToKICNpZiBVU0UoQ0cpCiAgICAgdm9pZCBzd2FwKFBhdGgmKTsKLSAgICB2b2lkIGluaXRp YWxpemVPckNvcHlQbGF0Zm9ybVBhdGhJZk5lZWRlZCgpOwogI2VuZGlmCiAKICNpZiBVU0UoRElS RUNUMkQpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Q YXRoQ0cuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNw cAppbmRleCA1N2QzNGE5MTNmNDllZjUyY2Y0OWY5Njg2MjZlYzBhNzdmMjJmMDRhLi45YTBkOTM0 ZWNmOWY3MmY5M2U1M2Y5MDRlODFjNDNmZTk3NDA0NWQzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAKQEAgLTEwMCw3ICsxMDAsMTMgQEAgUGF0 aDo6flBhdGgoKQogCiBQbGF0Zm9ybVBhdGhQdHIgUGF0aDo6ZW5zdXJlUGxhdGZvcm1QYXRoKCkK IHsKLSAgICBpbml0aWFsaXplT3JDb3B5UGxhdGZvcm1QYXRoSWZOZWVkZWQoKTsKKyAgICBpZiAo IW1fcGF0aCkKKyAgICAgICAgbV9wYXRoID0gQ0dQYXRoQ3JlYXRlTXV0YWJsZSgpOworICAgIGVs c2UgaWYgKG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbikgeworICAgICAgICBpZiAoQ0ZHZXRSZXRh aW5Db3VudChtX3BhdGgpID4gMSkKKyAgICAgICAgICAgIENGUmVsZWFzZShzdGQ6OmV4Y2hhbmdl KG1fcGF0aCwgQ0dQYXRoQ3JlYXRlTXV0YWJsZUNvcHkobV9wYXRoKSkpOworICAgICAgICBtX2Nv cHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKKyAgICB9CiAgICAgcmV0dXJuIG1fcGF0aDsK IH0KIApAQCAtMTI2LDIzICsxMzIsNiBAQCB2b2lkIFBhdGg6OnN3YXAoUGF0aCYgb3RoZXJQYXRo KQogICAgIHN0ZDo6c3dhcChtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24sIG90aGVyUGF0aC5tX2Nv cHlQYXRoQmVmb3JlTXV0YXRpb24pOwogfQogCi12b2lkIFBhdGg6OmluaXRpYWxpemVPckNvcHlQ bGF0Zm9ybVBhdGhJZk5lZWRlZCgpCi17Ci0gICAgaWYgKCFtX3BhdGgpIHsKLSAgICAgICAgbV9w YXRoID0gQ0dQYXRoQ3JlYXRlTXV0YWJsZSgpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotCi0g ICAgaWYgKG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbikgewotICAgICAgICBpZiAoQ0ZHZXRSZXRh aW5Db3VudChtX3BhdGgpID4gMSkgewotICAgICAgICAgICAgYXV0byBwYXRoVG9Db3B5ID0gbV9w YXRoOwotICAgICAgICAgICAgbV9wYXRoID0gQ0dQYXRoQ3JlYXRlTXV0YWJsZUNvcHkocGF0aFRv Q29weSk7Ci0gICAgICAgICAgICBDRlJlbGVhc2UocGF0aFRvQ29weSk7Ci0gICAgICAgIH0KLSAg ICAgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uID0gZmFsc2U7Ci0gICAgfQotfQotCiBQYXRo JiBQYXRoOjpvcGVyYXRvcj0oY29uc3QgUGF0aCYgb3RoZXIpCiB7CiAgICAgUGF0aCBjb3B5IHsg b3RoZXIgfTsK