145282 2015-05-21 13:53:57 -0700 MediaDevices.getUserMedia should reject promise instead of throwing exceptions 2015-05-29 01:10:24 -0700 1 1 1 Unclassified WebKit WebCore JavaScript 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 143211 1 youennf youennf adam.bergkvist commit-queue eric.carlson pnormand oldest_to_newest 1096665 0 youennf 2015-05-21 13:53:57 -0700 As per http://w3c.github.io/mediacapture-main/archives/20150324/getusermedia.html#dom-mediadevices-getusermedia, all exceptions or errors should be passed to the web application by rejecting the promise. 1096667 1 253541 youennf 2015-05-21 13:59:36 -0700 Created attachment 253541 Patch 1096792 2 253541 youennf 2015-05-21 23:15:11 -0700 Comment on attachment 253541 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=253541&action=review > Source/WebCore/Modules/mediastream/MediaDevices.h:59 > + typedef std::function<void(NavigatorUserMediaError*)> RejectCallback; Can we resolve/reject with nullptr for getUserMedia? I guess it is not the case but I am not sure. We may want to pass parameters as references (& or Ref<>&&) if possible, probably once PassRefPtr<>, RefPtr<>, Ref<> cleaning is done. > Source/WebCore/Modules/mediastream/UserMediaRequest.cpp:172 > + RefPtr<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, privateStream); Can stream be null? Can we use a Ref<> instead? > Source/WebCore/Modules/mediastream/UserMediaRequest.cpp:187 > RefPtr<NavigatorUserMediaError> error = NavigatorUserMediaError::create(NavigatorUserMediaError::constraintNotSatisfiedErrorName(), constraintName); Can error be null? Ca we use a Ref<> instead? > LayoutTests/fast/mediastream/MediaDevices-getUserMedia-expected.txt:-8 > -PASS navigator.mediaDevices.webkitGetUserMedia({audio:true}); threw exception TypeError: navigator.mediaDevices.webkitGetUserMedia is not a function. (In 'navigator.mediaDevices.webkitGetUserMedia({audio:true})', 'navigator.mediaDevices.webkitGetUserMedia' is undefined). This last test case is strange. Is it what we want to test? I changed it to "navigator.mediaDevices.getUserMedia({audivide:true})" 1096815 3 253541 youennf 2015-05-22 01:11:42 -0700 Comment on attachment 253541 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=253541&action=review > Source/WebCore/Modules/mediastream/UserMediaRequest.cpp:83 > + errorCallback->handleEvent(error); With the proposed changes, the rejectCallback may be called synchronously now. The promise implementation ensures that JS callbacks are called asynchronously. But for webkitGetUserMedia, after looking at http://w3c.github.io/mediacapture-main/getusermedia.html#navigatorusermedia-interface-extensions, this is probably an issue. We may emulate asynchronous promise callback execution with something like: RefPtr<NavigatorUserMediaError> protectedError = error; scriptExecutionContext()->postTask([errorCallback, protectedError] { errorCallback->handleEvent(protectedError.get()); }); Or think of a better way to do the same thing (handling at promise level just like the spec says). successCallback might need to have the same treatment for consistency purposes. Also, this might need a dedicated test case, since it seems the tests do not capture that. Rethinking about it, splitting the patch in two might make sense. I will wait for some feedback before doing anything, maybe I am overlooking things. 1096817 4 adam.bergkvist 2015-05-22 01:22:02 -0700 (In reply to comment #2) > Comment on attachment 253541 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=253541&action=review > > > Source/WebCore/Modules/mediastream/MediaDevices.h:59 > > + typedef std::function<void(NavigatorUserMediaError*)> RejectCallback; > > Can we resolve/reject with nullptr for getUserMedia? > I guess it is not the case but I am not sure. > We may want to pass parameters as references (& or Ref<>&&) if possible, > probably once PassRefPtr<>, RefPtr<>, Ref<> cleaning is done. No. Always a MediaSteram or an error. > > > Source/WebCore/Modules/mediastream/UserMediaRequest.cpp:172 > > + RefPtr<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, privateStream); > > Can stream be null? Can we use a Ref<> instead? > > > Source/WebCore/Modules/mediastream/UserMediaRequest.cpp:187 > > RefPtr<NavigatorUserMediaError> error = NavigatorUserMediaError::create(NavigatorUserMediaError::constraintNotSatisfiedErrorName(), constraintName); > > Can error be null? Ca we use a Ref<> instead? > I believe the answer is no to both questions above. > > LayoutTests/fast/mediastream/MediaDevices-getUserMedia-expected.txt:-8 > > -PASS navigator.mediaDevices.webkitGetUserMedia({audio:true}); threw exception TypeError: navigator.mediaDevices.webkitGetUserMedia is not a function. (In 'navigator.mediaDevices.webkitGetUserMedia({audio:true})', 'navigator.mediaDevices.webkitGetUserMedia' is undefined). > > This last test case is strange. Is it what we want to test? > I changed it to "navigator.mediaDevices.getUserMedia({audivide:true})" MediaDevices.getUserMedia() is a rather late addition to the Media Capture and Streams spec [1]. It's sibling, on Navigator, has been along for quite some time, so when we decided to expose the Promised-based version on the MediaDevices object, we said that implementations should not vendor prefix it since the functionality is rather mature. So this test is intended to check that. [1] https://w3c.github.io/mediacapture-main/ 1096821 5 adam.bergkvist 2015-05-22 01:28:22 -0700 > > Can error be null? Ca we use a Ref<> instead? > > > > I believe the answer is no to both questions above. I realize my answer was a bit ambiguous. :) It can't be null, and yes, we could use Ref<> instead. 1096823 6 adam.bergkvist 2015-05-22 01:45:13 -0700 (In reply to comment #3) > Comment on attachment 253541 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=253541&action=review > > > Source/WebCore/Modules/mediastream/UserMediaRequest.cpp:83 > > + errorCallback->handleEvent(error); > > With the proposed changes, the rejectCallback may be called synchronously > now. > The promise implementation ensures that JS callbacks are called > asynchronously. > But for webkitGetUserMedia, after looking at > http://w3c.github.io/mediacapture-main/getusermedia.html#navigatorusermedia- > interface-extensions, this is probably an issue. > > We may emulate asynchronous promise callback execution with something like: > RefPtr<NavigatorUserMediaError> protectedError = error; > scriptExecutionContext()->postTask([errorCallback, protectedError] { > errorCallback->handleEvent(protectedError.get()); > }); > Or think of a better way to do the same thing (handling at promise level > just like the spec says). > > successCallback might need to have the same treatment for consistency > purposes. The invocations of resolveCallback and rejectCallback in UserMediaRequest.cpp (:172, 192, 205) are wrapped in callOnMainThread(). Does that address your concern? 1096825 7 253541 youennf 2015-05-22 02:42:29 -0700 Comment on attachment 253541 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=253541&action=review >>> Source/WebCore/Modules/mediastream/UserMediaRequest.cpp:83 >>> + errorCallback->handleEvent(error); >> >> With the proposed changes, the rejectCallback may be called synchronously now. >> The promise implementation ensures that JS callbacks are called asynchronously. >> But for webkitGetUserMedia, after looking at http://w3c.github.io/mediacapture-main/getusermedia.html#navigatorusermedia-interface-extensions, this is probably an issue. >> >> We may emulate asynchronous promise callback execution with something like: >> RefPtr<NavigatorUserMediaError> protectedError = error; >> scriptExecutionContext()->postTask([errorCallback, protectedError] { >> errorCallback->handleEvent(protectedError.get()); >> }); >> Or think of a better way to do the same thing (handling at promise level just like the spec says). >> >> successCallback might need to have the same treatment for consistency purposes. >> >> Also, this might need a dedicated test case, since it seems the tests do not capture that. >> Rethinking about it, splitting the patch in two might make sense. >> >> I will wait for some feedback before doing anything, maybe I am overlooking things. > > The invocations of resolveCallback and rejectCallback in UserMediaRequest.cpp (:172, 192, 205) are wrapped in callOnMainThread(). Does that address your concern? Yes and no ;) Using callOnMainThread would solve the concern for webkitGetUserMedia (although postTask would be better as it is what promise implementation uses for calling JS callbacks). But it creates an issue for MediaDevices.getUserMedia() as the postTask/callOnMainThread call is not needed at all to resolve/reject promise. The JS promise implementation is already doing that work. This makes things less efficient and less consistent. I will split that as a separate patch since it is less straightforward than I thought it would be. Let's first reject exceptions. >>> LayoutTests/fast/mediastream/MediaDevices-getUserMedia-expected.txt:-8 >>> -PASS navigator.mediaDevices.webkitGetUserMedia({audio:true}); threw exception TypeError: navigator.mediaDevices.webkitGetUserMedia is not a function. (In 'navigator.mediaDevices.webkitGetUserMedia({audio:true})', 'navigator.mediaDevices.webkitGetUserMedia' is undefined). >> >> This last test case is strange. Is it what we want to test? >> I changed it to "navigator.mediaDevices.getUserMedia({audivide:true})" > > MediaDevices.getUserMedia() is a rather late addition to the Media Capture and Streams spec [1]. It's sibling, on Navigator, has been along for quite some time, so when we decided to expose the Promised-based version on the MediaDevices object, we said that implementations should not vendor prefix it since the functionality is rather mature. So this test is intended to check that. > > [1] https://w3c.github.io/mediacapture-main/ OK. Asserting that navigator.mediaDevices.webkitGetUserMedia is undefined might be clearer then? 1096828 8 253586 youennf 2015-05-22 02:56:16 -0700 Created attachment 253586 Removing async promise resolution/rejection changes 1096832 9 youennf 2015-05-22 03:06:05 -0700 > > The invocations of resolveCallback and rejectCallback in UserMediaRequest.cpp (:172, 192, 205) are wrapped in callOnMainThread(). Does that address your concern? > > Yes and no ;) > Using callOnMainThread would solve the concern for webkitGetUserMedia > (although postTask would be better as it is what promise implementation uses > for calling JS callbacks). > > But it creates an issue for MediaDevices.getUserMedia() as the > postTask/callOnMainThread call is not needed at all to resolve/reject > promise. > The JS promise implementation is already doing that work. > This makes things less efficient and less consistent. You can see an illustration of the issue in the -expected.txt generated by the latest patch. The order of the callback execution is not really what we would expect. First, all promise rejection callbacks are called asynchronously which is good. But the empty dictionary test is displayed before the {audio:true} test for instance. Reason is the custom binding is implemented with just one postTask. The rejection done in UserMediaRequest is implemented with one callOnnMainThread followed by one postTask. 1096844 10 adam.bergkvist 2015-05-22 04:42:37 -0700 (In reply to comment #7) > OK. > Asserting that navigator.mediaDevices.webkitGetUserMedia is undefined might > be clearer then? Yes, that's better. (In reply to comment #9) > > > The invocations of resolveCallback and rejectCallback in UserMediaRequest.cpp (:172, 192, 205) are wrapped in callOnMainThread(). Does that address your concern? > > > > Yes and no ;) > > Using callOnMainThread would solve the concern for webkitGetUserMedia > > (although postTask would be better as it is what promise implementation uses > > for calling JS callbacks). > > > > But it creates an issue for MediaDevices.getUserMedia() as the > > postTask/callOnMainThread call is not needed at all to resolve/reject > > promise. > > The JS promise implementation is already doing that work. > > This makes things less efficient and less consistent. > > You can see an illustration of the issue in the -expected.txt generated by > the latest patch. > The order of the callback execution is not really what we would expect. > > First, all promise rejection callbacks are called asynchronously which is > good. > > But the empty dictionary test is displayed before the {audio:true} test for > instance. > > Reason is the custom binding is implemented with just one postTask. > The rejection done in UserMediaRequest is implemented with one > callOnnMainThread followed by one postTask. The double scheduling is not ideal indeed. I believe your proposal to move the scheduling needed for the callback case into the lambda functions does the trick right? 1096851 11 youennf 2015-05-22 05:02:27 -0700 (In reply to comment #10) > > Reason is the custom binding is implemented with just one postTask. > > The rejection done in UserMediaRequest is implemented with one > > callOnnMainThread followed by one postTask. > > The double scheduling is not ideal indeed. I believe your proposal to move > the scheduling needed for the callback case into the lambda functions does > the trick right? Yes. I filed bug 145308 for that purpose. 1096852 12 youennf 2015-05-22 05:07:24 -0700 As a side note, the spec http://w3c.github.io/mediacapture-main/archives/20150324/getusermedia.html calls somehow for that double scheduing. In particular, it says that step 3 should be done asynchronously. Might be worth some spec editing maybe. Should I file a github issue? 1096853 13 adam.bergkvist 2015-05-22 05:28:37 -0700 Please, file an issue. 1097359 14 253586 darin 2015-05-26 11:44:22 -0700 Comment on attachment 253586 Removing async promise resolution/rejection changes View in context: https://bugs.webkit.org/attachment.cgi?id=253586&action=review > Source/WebCore/Modules/mediastream/MediaDevices.h:59 > + typedef std::function<void(MediaStream*)> ResolveCallback; > + typedef std::function<void(NavigatorUserMediaError*)> RejectCallback; Why pointers and not references? Can these ever be null? 1097436 15 253586 youennf 2015-05-26 14:13:14 -0700 Comment on attachment 253586 Removing async promise resolution/rejection changes View in context: https://bugs.webkit.org/attachment.cgi?id=253586&action=review >> Source/WebCore/Modules/mediastream/MediaDevices.h:59 >> + typedef std::function<void(NavigatorUserMediaError*)> RejectCallback; > > Why pointers and not references? Can these ever be null? Thanks for reminding me of this point. I checked with Adam and he said references are fine. I will clean this when landing. 1097855 16 youennf 2015-05-27 23:42:37 -0700 (In reply to comment #13) > Please, file an issue. Filed https://github.com/w3c/mediacapture-main/issues/174 for that purpose. 1097940 17 253858 youennf 2015-05-28 13:26:39 -0700 Created attachment 253858 Patch for landing 1098100 18 253858 commit-queue 2015-05-29 01:10:20 -0700 Comment on attachment 253858 Patch for landing Clearing flags on attachment: 253858 Committed r184984: <http://trac.webkit.org/changeset/184984> 1098101 19 commit-queue 2015-05-29 01:10:24 -0700 All reviewed patches have been landed. Closing bug. 253541 2015-05-21 13:59:36 -0700 2015-05-22 02:56:09 -0700 Patch bug-145282-20150521225930.patch text/plain 12574 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTg0NzExCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTg5MjAwMTdmMWVkYjFk YmQ2YjRlY2E3NjRjMTE5YTNmYmQ3ODcxNi4uYWE2NDI3MTg1MGVlYzhkM2MzODZlZGFiY2E4NjU3 OWRhNWJkOGFlYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDE1LTA1LTIxICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgTWVkaWFE ZXZpY2VzLmdldFVzZXJNZWRpYSBzaG91bGQgcmVqZWN0IHByb21pc2UgaW5zdGVhZCBvZiB0aHJv d2luZyBleGNlcHRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xNDUyODIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBFbnN1cmluZyBhdCB0aGUgY3VzdG9tIGJpbmRpbmcgbGV2ZWwgdGhhdCBhbGwgcG90 ZW50aWFsIGVycm9ycyBhcmUgdXNlZCB0byByZWplY3QgcHJvbWlzZS4KKyAgICAgICAgQ2xlYW5l ZCB1cCB0aGUgd3JhcHBlcnMgYnkgcmVtb3ZpbmcgdW5uZWVkZWQgUmVmUHRyLgorICAgICAgICBS ZW1vdmVkIHVubmVlZGVkIGNhbGxzIHRvIGNhbGxPbk1haW5UaHJlYWQgd2hlbiByZXNvbHZpbmcv cmVqZWN0aW5nIGNhbGxiYWNrcy4KKworICAgICAgICBDb3ZlcmVkIGJ5IG1vZGlmaWVkIHRlc3Qu CisKKyAgICAgICAgKiBNb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpNZWRpYURldmljZXM6OmdldFVzZXJNZWRpYSk6CisgICAgICAgICogTW9k dWxlcy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaDoKKyAgICAgICAgKiBNb2R1bGVzL21lZGlh c3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlh UmVxdWVzdDo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmRp ZENyZWF0ZVN0cmVhbSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpmYWls ZWRUb0NyZWF0ZVN0cmVhbVdpdGhDb25zdHJhaW50c0Vycm9yKToKKyAgICAgICAgKFdlYkNvcmU6 OlVzZXJNZWRpYVJlcXVlc3Q6OmZhaWxlZFRvQ3JlYXRlU3RyZWFtV2l0aFBlcm1pc3Npb25FcnJv cik6CisgICAgICAgICogYmluZGluZ3MvanMvSlNNZWRpYURldmljZXNDdXN0b20uY3BwOgorICAg ICAgICAoV2ViQ29yZTo6SlNNZWRpYURldmljZXM6OmdldFVzZXJNZWRpYSk6CisKIDIwMTUtMDUt MjEgIEd5dXlvdW5nIEtpbSAgPGd5dXlvdW5nLmtpbUB3ZWJraXQub3JnPgogCiAgICAgICAgIFB1 cmdlIFBhc3NSZWZQdHIgaW4gV2ViQ29yZS9Nb2R1bGVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5jcHAKaW5kZXggMGU3NjBkOTdiZGRm NDQwZmQ4NWVmYzE5YTk2NzY5ZjYzZDYwMGJiZC4uMDJmYmM4NjRjYmE2MzA4YmY4YWJiZjMyMjFk ZWI4OTc5ZDU0NWQzNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0 cmVhbS9NZWRpYURldmljZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFz dHJlYW0vTWVkaWFEZXZpY2VzLmNwcApAQCAtNjQsNiArNjQsNyBAQCB2b2lkIE1lZGlhRGV2aWNl czo6Z2V0VXNlck1lZGlhKGNvbnN0IERpY3Rpb25hcnkmIG9wdGlvbnMsIFJlc29sdmVDYWxsYmFj ayByZXNvbAogewogICAgIFVzZXJNZWRpYUNvbnRyb2xsZXIqIHVzZXJNZWRpYSA9IFVzZXJNZWRp YUNvbnRyb2xsZXI6OmZyb20oZG9jdW1lbnQoKSA/IGRvY3VtZW50KCktPnBhZ2UoKSA6IG51bGxw dHIpOwogICAgIGlmICghdXNlck1lZGlhKSB7CisgICAgICAgIC8vIEZJWE1FOiBXZSBwcm9iYWJs eSB3YW50IHRvIHJldHVybiBhIE1lZGlhU3RyZWFtRXJyb3IgaGVyZSB1c2luZyB0aGUgcmVqZWN0 Q2FsbGJhY2ssIGFuZCBnZXQgcmlkIG9mZiB0aGUgRXhjZXB0aW9uQ29kZSBwYXJhbWV0ZXIuCiAg ICAgICAgIGVjID0gTk9UX1NVUFBPUlRFRF9FUlI7CiAgICAgICAgIHJldHVybjsKICAgICB9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNl cy5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaApp bmRleCAxOWNjZGRiYTUzODA3ZTBiMGExY2M2NGRmODQzYmJlYzU0ZTExNjhmLi5jMjQ2Y2E4MmE5 Njk4MGZhN2RhOTNhNzkzNjhmYzcyZTYzN2Q4NDcxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLmgKQEAgLTU1LDggKzU1LDggQEAgcHVi bGljOgogCiAgICAgRG9jdW1lbnQqIGRvY3VtZW50KCkgY29uc3Q7CiAKLSAgICB0eXBlZGVmIHN0 ZDo6ZnVuY3Rpb248dm9pZChSZWZQdHI8TWVkaWFTdHJlYW0+KT4gUmVzb2x2ZUNhbGxiYWNrOwot ICAgIHR5cGVkZWYgc3RkOjpmdW5jdGlvbjx2b2lkKFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFF cnJvcj4pPiBSZWplY3RDYWxsYmFjazsKKyAgICB0eXBlZGVmIHN0ZDo6ZnVuY3Rpb248dm9pZChN ZWRpYVN0cmVhbSopPiBSZXNvbHZlQ2FsbGJhY2s7CisgICAgdHlwZWRlZiBzdGQ6OmZ1bmN0aW9u PHZvaWQoTmF2aWdhdG9yVXNlck1lZGlhRXJyb3IqKT4gUmVqZWN0Q2FsbGJhY2s7CiAKICAgICB2 b2lkIGdldFVzZXJNZWRpYShjb25zdCBEaWN0aW9uYXJ5JiwgUmVzb2x2ZUNhbGxiYWNrLCBSZWpl Y3RDYWxsYmFjaywgRXhjZXB0aW9uQ29kZSYpIGNvbnN0OwogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwIGIvU291cmNl L1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmNwcAppbmRleCA0 YTlhZTYzZTUxYjcxZWRlNzBkYWIzNDQyNmEzMGUyMGY1NTM2ODI4Li5hOThhYzQ3NjM0MjYzNjk3 YTA4MTliMDQ1ZTlmZDM4NjNkNTkwZjM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1 bGVzL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHAKQEAgLTc1LDEyICs3NSwx MiBAQCBQYXNzUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IFVzZXJNZWRpYVJlcXVlc3Q6OmNyZWF0 ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjbwogewogICAgIEFTU0VSVChzdWNjZXNzQ2FsbGJh Y2spOwogCi0gICAgYXV0byByZXNvbHZlQ2FsbGJhY2sgPSBbc3VjY2Vzc0NhbGxiYWNrXShSZWZQ dHI8TWVkaWFTdHJlYW0+IHN0cmVhbSkgbXV0YWJsZSB7Ci0gICAgICAgIHN1Y2Nlc3NDYWxsYmFj ay0+aGFuZGxlRXZlbnQoc3RyZWFtLmdldCgpKTsKKyAgICBhdXRvIHJlc29sdmVDYWxsYmFjayA9 IFtzdWNjZXNzQ2FsbGJhY2tdKE1lZGlhU3RyZWFtKiBzdHJlYW0pIG11dGFibGUgeworICAgICAg ICBzdWNjZXNzQ2FsbGJhY2stPmhhbmRsZUV2ZW50KHN0cmVhbSk7CiAgICAgfTsKLSAgICBhdXRv IHJlamVjdENhbGxiYWNrID0gW2Vycm9yQ2FsbGJhY2tdKFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVk aWFFcnJvcj4gZXJyb3IpIG11dGFibGUgeworICAgIGF1dG8gcmVqZWN0Q2FsbGJhY2sgPSBbZXJy b3JDYWxsYmFja10oTmF2aWdhdG9yVXNlck1lZGlhRXJyb3IqIGVycm9yKSBtdXRhYmxlIHsKICAg ICAgICAgaWYgKGVycm9yQ2FsbGJhY2spCi0gICAgICAgICAgICBlcnJvckNhbGxiYWNrLT5oYW5k bGVFdmVudChlcnJvci5nZXQoKSk7CisgICAgICAgICAgICBlcnJvckNhbGxiYWNrLT5oYW5kbGVF dmVudChlcnJvcik7CiAgICAgfTsKIAogICAgIHJldHVybiBVc2VyTWVkaWFSZXF1ZXN0OjpjcmVh dGUoY29udGV4dCwgY29udHJvbGxlciwgb3B0aW9ucywgV1RGOjptb3ZlKHJlc29sdmVDYWxsYmFj ayksIFdURjo6bW92ZShyZWplY3RDYWxsYmFjayksIGVjKTsKQEAgLTE2OCwxNyArMTY4LDE0IEBA IHZvaWQgVXNlck1lZGlhUmVxdWVzdDo6ZGlkQ3JlYXRlU3RyZWFtKFBhc3NSZWZQdHI8TWVkaWFT dHJlYW1Qcml2YXRlPiBwcml2YXRlU3RyCiAgICAgaWYgKCFtX3NjcmlwdEV4ZWN1dGlvbkNvbnRl eHQpCiAgICAgICAgIHJldHVybjsKIAotICAgIFJlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiBwcm90 ZWN0ZWRUaGlzKHRoaXMpOwotICAgIGNhbGxPbk1haW5UaHJlYWQoW3Byb3RlY3RlZFRoaXMsIHBy aXZhdGVTdHJlYW1dIHsKLSAgICAgICAgLy8gNCAtIENyZWF0ZSB0aGUgTWVkaWFTdHJlYW0gYW5k IHBhc3MgaXQgdG8gdGhlIHN1Y2Nlc3MgY2FsbGJhY2suCi0gICAgICAgIFJlZlB0cjxNZWRpYVN0 cmVhbT4gc3RyZWFtID0gTWVkaWFTdHJlYW06OmNyZWF0ZSgqcHJvdGVjdGVkVGhpcy0+bV9zY3Jp cHRFeGVjdXRpb25Db250ZXh0LCBwcml2YXRlU3RyZWFtKTsKLSAgICAgICAgZm9yIChhdXRvJiB0 cmFjayA6IHN0cmVhbS0+Z2V0QXVkaW9UcmFja3MoKSkKLSAgICAgICAgICAgIHRyYWNrLT5hcHBs eUNvbnN0cmFpbnRzKHByb3RlY3RlZFRoaXMtPm1fYXVkaW9Db25zdHJhaW50cyk7Ci0gICAgICAg IGZvciAoYXV0byYgdHJhY2sgOiBzdHJlYW0tPmdldFZpZGVvVHJhY2tzKCkpCi0gICAgICAgICAg ICB0cmFjay0+YXBwbHlDb25zdHJhaW50cyhwcm90ZWN0ZWRUaGlzLT5tX3ZpZGVvQ29uc3RyYWlu dHMpOwotCi0gICAgICAgIHByb3RlY3RlZFRoaXMtPm1fcmVzb2x2ZUNhbGxiYWNrKHN0cmVhbS5n ZXQoKSk7Ci0gICAgfSk7CisgICAgLy8gNCAtIENyZWF0ZSB0aGUgTWVkaWFTdHJlYW0gYW5kIHBh c3MgaXQgdG8gdGhlIHN1Y2Nlc3MgY2FsbGJhY2suCisgICAgUmVmUHRyPE1lZGlhU3RyZWFtPiBz dHJlYW0gPSBNZWRpYVN0cmVhbTo6Y3JlYXRlKCptX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIHBy aXZhdGVTdHJlYW0pOworICAgIGZvciAoYXV0byYgdHJhY2sgOiBzdHJlYW0tPmdldEF1ZGlvVHJh Y2tzKCkpCisgICAgICAgIHRyYWNrLT5hcHBseUNvbnN0cmFpbnRzKG1fYXVkaW9Db25zdHJhaW50 cyk7CisgICAgZm9yIChhdXRvJiB0cmFjayA6IHN0cmVhbS0+Z2V0VmlkZW9UcmFja3MoKSkKKyAg ICAgICAgdHJhY2stPmFwcGx5Q29uc3RyYWludHMobV92aWRlb0NvbnN0cmFpbnRzKTsKKworICAg IG1fcmVzb2x2ZUNhbGxiYWNrKHN0cmVhbS5nZXQoKSk7CiB9CiAKIHZvaWQgVXNlck1lZGlhUmVx dWVzdDo6ZmFpbGVkVG9DcmVhdGVTdHJlYW1XaXRoQ29uc3RyYWludHNFcnJvcihjb25zdCBTdHJp bmcmIGNvbnN0cmFpbnROYW1lKQpAQCAtMTg3LDExICsxODQsOCBAQCB2b2lkIFVzZXJNZWRpYVJl cXVlc3Q6OmZhaWxlZFRvQ3JlYXRlU3RyZWFtV2l0aENvbnN0cmFpbnRzRXJyb3IoY29uc3QgU3Ry aW5nJiBjbwogICAgIGlmICghbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0KQogICAgICAgICByZXR1 cm47CiAKLSAgICBSZWZQdHI8VXNlck1lZGlhUmVxdWVzdD4gcHJvdGVjdGVkVGhpcyh0aGlzKTsK ICAgICBSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+IGVycm9yID0gTmF2aWdhdG9yVXNl ck1lZGlhRXJyb3I6OmNyZWF0ZShOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y29uc3RyYWludE5v dFNhdGlzZmllZEVycm9yTmFtZSgpLCBjb25zdHJhaW50TmFtZSk7Ci0gICAgY2FsbE9uTWFpblRo cmVhZChbcHJvdGVjdGVkVGhpcywgZXJyb3JdIHsKLSAgICAgICAgcHJvdGVjdGVkVGhpcy0+bV9y ZWplY3RDYWxsYmFjayhlcnJvci5nZXQoKSk7Ci0gICAgfSk7CisgICAgbV9yZWplY3RDYWxsYmFj ayhlcnJvci5nZXQoKSk7CiB9CiAKIHZvaWQgVXNlck1lZGlhUmVxdWVzdDo6ZmFpbGVkVG9DcmVh dGVTdHJlYW1XaXRoUGVybWlzc2lvbkVycm9yKCkKQEAgLTE5OSwxMiArMTkzLDkgQEAgdm9pZCBV c2VyTWVkaWFSZXF1ZXN0OjpmYWlsZWRUb0NyZWF0ZVN0cmVhbVdpdGhQZXJtaXNzaW9uRXJyb3Io KQogICAgIGlmICghbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0KQogICAgICAgICByZXR1cm47CiAK LSAgICBSZWZQdHI8VXNlck1lZGlhUmVxdWVzdD4gcHJvdGVjdGVkVGhpcyh0aGlzKTsKICAgICAv LyBGSVhNRTogUmVwbGFjZSBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvciB3aXRoIE1lZGlhU3RyZWFt RXJyb3IgKHNlZSBidWcgMTQzMzM1KQogICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJv cj4gZXJyb3IgPSBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y3JlYXRlKE5hdmlnYXRvclVzZXJN ZWRpYUVycm9yOjpwZXJtaXNzaW9uRGVuaWVkRXJyb3JOYW1lKCksIGVtcHR5U3RyaW5nKCkpOwot ICAgIGNhbGxPbk1haW5UaHJlYWQoW3Byb3RlY3RlZFRoaXMsIGVycm9yXSB7Ci0gICAgICAgIHBy b3RlY3RlZFRoaXMtPm1fcmVqZWN0Q2FsbGJhY2soZXJyb3IuZ2V0KCkpOwotICAgIH0pOworICAg IG1fcmVqZWN0Q2FsbGJhY2soZXJyb3IuZ2V0KCkpOwogfQogCiB2b2lkIFVzZXJNZWRpYVJlcXVl c3Q6OmNvbnRleHREZXN0cm95ZWQoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGlu Z3MvanMvSlNNZWRpYURldmljZXNDdXN0b20uY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv anMvSlNNZWRpYURldmljZXNDdXN0b20uY3BwCmluZGV4IGU0MDFhYjBkMGIxODYzOTJmMmUxYjRm YTI2NmQ5ZDE3NjAyMzQ5YzkuLmYzNTNkMmRhMjZkODg2Y2E0YTNmNTE5NGYyZDI1M2FmNWFmZTIx MjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTTWVkaWFEZXZpY2Vz Q3VzdG9tLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU01lZGlhRGV2aWNl c0N1c3RvbS5jcHAKQEAgLTQ2LDI5ICs0NiwzMSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIEpT VmFsdWUgSlNNZWRpYURldmljZXM6OmdldFVzZXJNZWRpYShFeGVjU3RhdGUqIGV4ZWMpCiB7Cisg ICAgRGVmZXJyZWRXcmFwcGVyIHdyYXBwZXIoZXhlYywgZ2xvYmFsT2JqZWN0KCkpOworCiAgICAg RGljdGlvbmFyeSBvcHRpb25zKGV4ZWMsIGV4ZWMtPmFyZ3VtZW50KDApKTsKLSAgICBpZiAoZXhl Yy0+aGFkRXhjZXB0aW9uKCkpCi0gICAgICAgIHJldHVybiBqc1VuZGVmaW5lZCgpOworICAgIGlm IChleGVjLT5oYWRFeGNlcHRpb24oKSkgeworICAgICAgICB3cmFwcGVyLnJlamVjdChleGVjLT5l eGNlcHRpb24oKSk7CisgICAgICAgIHJldHVybiB3cmFwcGVyLnByb21pc2UoKTsKKyAgICB9CiAK ICAgICBpZiAoIW9wdGlvbnMuaXNPYmplY3QoKSkgewotICAgICAgICB0aHJvd1ZNRXJyb3IoZXhl YywgY3JlYXRlVHlwZUVycm9yKGV4ZWMsICJGaXJzdCBhcmd1bWVudCBvZiBnZXRVc2VyTWVkaWEg bXVzdCBiZSBhIHZhbGlkIERpY3Rpb25hcnkiKSk7Ci0gICAgICAgIHJldHVybiBqc1VuZGVmaW5l ZCgpOworICAgICAgICBKU1ZhbHVlIGVycm9yID0gY3JlYXRlVHlwZUVycm9yKGV4ZWMsICJGaXJz dCBhcmd1bWVudCBvZiBnZXRVc2VyTWVkaWEgbXVzdCBiZSBhIHZhbGlkIERpY3Rpb25hcnkiKTsK KyAgICAgICAgd3JhcHBlci5yZWplY3QoZXJyb3IpOworICAgICAgICByZXR1cm4gd3JhcHBlci5w cm9taXNlKCk7CiAgICAgfQogCi0gICAgRGVmZXJyZWRXcmFwcGVyIHdyYXBwZXIoZXhlYywgZ2xv YmFsT2JqZWN0KCkpOwotICAgIGF1dG8gcmVzb2x2ZUNhbGxiYWNrID0gW3dyYXBwZXJdKFJlZlB0 cjxNZWRpYVN0cmVhbT4gc3RyZWFtKSBtdXRhYmxlIHsKLSAgICAgICAgd3JhcHBlci5yZXNvbHZl KHN0cmVhbS5nZXQoKSk7CisgICAgYXV0byByZXNvbHZlQ2FsbGJhY2sgPSBbd3JhcHBlcl0oTWVk aWFTdHJlYW0qIHN0cmVhbSkgbXV0YWJsZSB7CisgICAgICAgIHdyYXBwZXIucmVzb2x2ZShzdHJl YW0pOwogICAgIH07Ci0gICAgYXV0byByZWplY3RDYWxsYmFjayA9IFt3cmFwcGVyXShSZWZQdHI8 TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+IGVycm9yKSBtdXRhYmxlIHsKLSAgICAgICAgd3JhcHBl ci5yZWplY3QoZXJyb3IuZ2V0KCkpOworICAgIGF1dG8gcmVqZWN0Q2FsbGJhY2sgPSBbd3JhcHBl cl0oTmF2aWdhdG9yVXNlck1lZGlhRXJyb3IqIGVycm9yKSBtdXRhYmxlIHsKKyAgICAgICAgd3Jh cHBlci5yZWplY3QoZXJyb3IpOwogICAgIH07CiAKICAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsK ICAgICBpbXBsKCkuZ2V0VXNlck1lZGlhKG9wdGlvbnMsIFdURjo6bW92ZShyZXNvbHZlQ2FsbGJh Y2spLCBXVEY6Om1vdmUocmVqZWN0Q2FsbGJhY2spLCBlYyk7Ci0gICAgaWYgKGVjKSB7Ci0gICAg ICAgIHNldERPTUV4Y2VwdGlvbihleGVjLCBlYyk7Ci0gICAgICAgIHJldHVybiBqc1VuZGVmaW5l ZCgpOwotICAgIH0KKyAgICBpZiAoZWMpCisgICAgICAgIHdyYXBwZXIucmVqZWN0KGVjKTsKIAog ICAgIHJldHVybiB3cmFwcGVyLnByb21pc2UoKTsKIH0KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA0YmY4OWJkYjdmY2RkNTZk NmNlMjY5YWMwMjU4OWQ4NTk3ZDc5Mzg0Li5mNWQwMTljM2FkNzE5OGE4YjljNGRkOWY1NmIzMmIz NDI1OGU4YTJhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTUtMDUtMjEgIFlvdWVubiBGYWJs ZXQgIDx5b3Vlbm4uZmFibGV0QGNyZi5jYW5vbi5mcj4KKworICAgICAgICBNZWRpYURldmljZXMu Z2V0VXNlck1lZGlhIHNob3VsZCByZWplY3QgcHJvbWlzZSBpbnN0ZWFkIG9mIHRocm93aW5nIGV4 Y2VwdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE0NTI4MgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFVwZGF0aW5nIHRlc3QgdG8gZXhwZWN0IHJlamVjdGlvbiBhbmQgbm90IGVycm9yIHRocm93aW5n LgorCisgICAgICAgICogZmFzdC9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMtZ2V0VXNlck1lZGlh LWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBmYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy1n ZXRVc2VyTWVkaWEuaHRtbDoKKwogMjAxNS0wNS0yMCAgSm9zZXBoIFBlY29yYXJvICA8cGVjb3Jh cm9AYXBwbGUuY29tPgogCiAgICAgICAgIFdlYiBJbnNwZWN0b3I6IGFycmF5IHByZXZpZXdzIHNo b3VsZCBoYXZlIGEgbXVjaCBzbWFsbGVyIGNhcCBvbiB2YWx1ZXMKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVzZXJNZWRpYS1leHBlY3Rl ZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy1nZXRVc2Vy TWVkaWEtZXhwZWN0ZWQudHh0CmluZGV4IGI1YWU4MWIyNTQ5MjNhNjQ1YzJmMjZmMDM4MGRmMmFj NGI5ZjE5OTIuLmNiMDg1OTBlNTcwNjRmMDNhMzcwODVkYzQ0MTFiYjY5ZGRhNTYzMDUgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVzZXJN ZWRpYS1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9tZWRpYXN0cmVhbS9NZWRp YURldmljZXMtZ2V0VXNlck1lZGlhLWV4cGVjdGVkLnR4dApAQCAtMywxMCArMywxMCBAQCBUZXN0 cyBnZXRVc2VyTWVkaWEgKFByb21pc2UtYmFzZWQgdmVyc2lvbiBvbiBuYXZpZ2F0b3IubWVkaWFE ZXZpY2VzKQogT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNz YWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgogCiAKLVBBU1MgbmF2aWdhdG9yLm1l ZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoKTsgdGhyZXcgZXhjZXB0aW9uIFR5cGVFcnJvcjogRmly c3QgYXJndW1lbnQgb2YgZ2V0VXNlck1lZGlhIG11c3QgYmUgYSB2YWxpZCBEaWN0aW9uYXJ5Lgot UEFTUyBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7fSk7IHRocmV3IGV4Y2Vw dGlvbiBFcnJvcjogTm90U3VwcG9ydGVkRXJyb3I6IERPTSBFeGNlcHRpb24gOS4KLVBBU1MgbmF2 aWdhdG9yLm1lZGlhRGV2aWNlcy53ZWJraXRHZXRVc2VyTWVkaWEoe2F1ZGlvOnRydWV9KTsgdGhy ZXcgZXhjZXB0aW9uIFR5cGVFcnJvcjogbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy53ZWJraXRHZXRV c2VyTWVkaWEgaXMgbm90IGEgZnVuY3Rpb24uIChJbiAnbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy53 ZWJraXRHZXRVc2VyTWVkaWEoe2F1ZGlvOnRydWV9KScsICduYXZpZ2F0b3IubWVkaWFEZXZpY2Vz LndlYmtpdEdldFVzZXJNZWRpYScgaXMgdW5kZWZpbmVkKS4KIFBBU1MgbmF2aWdhdG9yLm1lZGlh RGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOnRydWV9KS50aGVuKGdvdFN0cmVhbTEpOyBkaWQg bm90IHRocm93IGV4Y2VwdGlvbi4KK1BBU1MgbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2Vy TWVkaWEoKSByZWplY3RlZCB3aXRoIGVycm9yOiBUeXBlRXJyb3I6IEZpcnN0IGFyZ3VtZW50IG9m IGdldFVzZXJNZWRpYSBtdXN0IGJlIGEgdmFsaWQgRGljdGlvbmFyeQorUEFTUyAgbmF2aWdhdG9y Lm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe30pIHJlamVjdGVkIHdpdGggZXJyb3I6IEVycm9y OiBOb3RTdXBwb3J0ZWRFcnJvcjogRE9NIEV4Y2VwdGlvbiA5CitQQVNTIG5hdmlnYXRvci5tZWRp YURldmljZXMuZ2V0VXNlck1lZGlhKHthdWRpdmlkZTp0cnVlfSkgcmVqZWN0ZWQgd2l0aCBlcnJv cjogRXJyb3I6IE5vdFN1cHBvcnRlZEVycm9yOiBET00gRXhjZXB0aW9uIDkKIFBBU1MgU3RyZWFt IGdlbmVyYXRlZC4KIFBBU1Mgc3RyZWFtLmdldEF1ZGlvVHJhY2tzKCkubGVuZ3RoIGlzIDEKIFBB U1Mgc3RyZWFtLmdldFZpZGVvVHJhY2tzKCkubGVuZ3RoIGlzIDAKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVzZXJNZWRpYS5odG1sIGIv TGF5b3V0VGVzdHMvZmFzdC9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMtZ2V0VXNlck1lZGlhLmh0 bWwKaW5kZXggODA2NTAxNTNiZDA2NDM4YTVkOTRmOTRhOTkxNzZjYzFiMGFmYThlZC4uMmFmNGYw NjQ4YWMwZjA1Y2Q2MTU2ZjY2MmU3ODMwODE3OGRiZWY1ZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVz dHMvZmFzdC9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMtZ2V0VXNlck1lZGlhLmh0bWwKKysrIGIv TGF5b3V0VGVzdHMvZmFzdC9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMtZ2V0VXNlck1lZGlhLmh0 bWwKQEAgLTc1LDkgKzc1LDE1IEBACiAgICAgICAgICAgICAgICAgc2hvdWxkTm90VGhyb3coIm5h dmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHt2aWRlbzp0cnVlfSkudGhlbihnb3RT dHJlYW0yKTsiKQogICAgICAgICAgICAgfQogCi0gICAgICAgICAgICBzaG91bGRUaHJvdygibmF2 aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoKTsiKTsKLSAgICAgICAgICAgIHNob3Vs ZFRocm93KCJuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7fSk7Iik7Ci0gICAg ICAgICAgICBzaG91bGRUaHJvdygibmF2aWdhdG9yLm1lZGlhRGV2aWNlcy53ZWJraXRHZXRVc2Vy TWVkaWEoe2F1ZGlvOnRydWV9KTsiKTsKKyAgICAgICAgICAgIG5hdmlnYXRvci5tZWRpYURldmlj ZXMuZ2V0VXNlck1lZGlhKCkudGhlbihpbnZhbGlkR290U3RyZWFtLCBmdW5jdGlvbihlcnJvcikg eworICAgICAgICAgICAgICAgIHRlc3RQYXNzZWQoIm5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0 VXNlck1lZGlhKCkgcmVqZWN0ZWQgd2l0aCBlcnJvcjogIiArIGVycm9yKTsKKyAgICAgICAgICAg IH0pOworICAgICAgICAgICAgbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe30p LnRoZW4oaW52YWxpZEdvdFN0cmVhbSwgZnVuY3Rpb24oZXJyb3IpIHsKKyAgICAgICAgICAgICAg ICB0ZXN0UGFzc2VkKCIgbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe30pIHJl amVjdGVkIHdpdGggZXJyb3I6ICIgKyBlcnJvcik7CisgICAgICAgICAgICB9KTsKKyAgICAgICAg ICAgIG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHthdWRpdmlkZTogdHJ1ZX0p LnRoZW4oaW52YWxpZEdvdFN0cmVhbSwgZnVuY3Rpb24oZXJyb3IpIHsKKyAgICAgICAgICAgICAg ICB0ZXN0UGFzc2VkKCJuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7YXVkaXZp ZGU6dHJ1ZX0pIHJlamVjdGVkIHdpdGggZXJyb3I6ICIgKyBlcnJvcik7CisgICAgICAgICAgICB9 KTsKICAgICAgICAgICAgIHNldFVzZXJNZWRpYVBlcm1pc3Npb24odHJ1ZSk7CiAgICAgICAgICAg ICBzaG91bGROb3RUaHJvdygibmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1 ZGlvOnRydWV9KS50aGVuKGdvdFN0cmVhbTEpOyIpOwogCg== 253586 2015-05-22 02:56:16 -0700 2015-05-28 13:26:27 -0700 Removing async promise resolution/rejection changes bug-145282-20150522115610.patch text/plain 9575 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTg0NzExCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTg5MjAwMTdmMWVkYjFk YmQ2YjRlY2E3NjRjMTE5YTNmYmQ3ODcxNi4uODUwOGU5NTg3ZmUyNTM0YTViMWIwMDRkZjNjM2I4 ZDhlNzVmOWJjNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDE1LTA1LTIyICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgTWVkaWFE ZXZpY2VzLmdldFVzZXJNZWRpYSBzaG91bGQgcmVqZWN0IHByb21pc2UgaW5zdGVhZCBvZiB0aHJv d2luZyBleGNlcHRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xNDUyODIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBFbnN1cmluZyBhdCB0aGUgY3VzdG9tIGJpbmRpbmcgbGV2ZWwgdGhhdCBhbGwgcG90 ZW50aWFsIGVycm9ycyBhcmUgdXNlZCB0byByZWplY3QgcHJvbWlzZS4KKyAgICAgICAgQ2xlYW5l ZCB1cCB0aGUgd3JhcHBlcnMgYnkgcmVtb3ZpbmcgdW5uZWVkZWQgUmVmUHRyLgorCisgICAgICAg IENvdmVyZWQgYnkgbW9kaWZpZWQgdGVzdC4KKworICAgICAgICAqIE1vZHVsZXMvbWVkaWFzdHJl YW0vTWVkaWFEZXZpY2VzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhRGV2aWNlczo6Z2V0 VXNlck1lZGlhKToKKyAgICAgICAgKiBNb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5o OgorICAgICAgICAqIE1vZHVsZXMvbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUpOgorICAgICAgICAqIGJp bmRpbmdzL2pzL0pTTWVkaWFEZXZpY2VzQ3VzdG9tLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkpT TWVkaWFEZXZpY2VzOjpnZXRVc2VyTWVkaWEpOgorCiAyMDE1LTA1LTIxICBHeXV5b3VuZyBLaW0g IDxneXV5b3VuZy5raW1Ad2Via2l0Lm9yZz4KIAogICAgICAgICBQdXJnZSBQYXNzUmVmUHRyIGlu IFdlYkNvcmUvTW9kdWxlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRp YXN0cmVhbS9NZWRpYURldmljZXMuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0 cmVhbS9NZWRpYURldmljZXMuY3BwCmluZGV4IDBlNzYwZDk3YmRkZjQ0MGZkODVlZmMxOWE5Njc2 OWY2M2Q2MDBiYmQuLjAyZmJjODY0Y2JhNjMwOGJmOGFiYmYzMjIxZGViODk3OWQ1NDVkMzYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2Vz LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNl cy5jcHAKQEAgLTY0LDYgKzY0LDcgQEAgdm9pZCBNZWRpYURldmljZXM6OmdldFVzZXJNZWRpYShj b25zdCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBSZXNvbHZlQ2FsbGJhY2sgcmVzb2wKIHsKICAgICBV c2VyTWVkaWFDb250cm9sbGVyKiB1c2VyTWVkaWEgPSBVc2VyTWVkaWFDb250cm9sbGVyOjpmcm9t KGRvY3VtZW50KCkgPyBkb2N1bWVudCgpLT5wYWdlKCkgOiBudWxscHRyKTsKICAgICBpZiAoIXVz ZXJNZWRpYSkgeworICAgICAgICAvLyBGSVhNRTogV2UgcHJvYmFibHkgd2FudCB0byByZXR1cm4g YSBNZWRpYVN0cmVhbUVycm9yIGhlcmUgdXNpbmcgdGhlIHJlamVjdENhbGxiYWNrLCBhbmQgZ2V0 IHJpZCBvZmYgdGhlIEV4Y2VwdGlvbkNvZGUgcGFyYW1ldGVyLgogICAgICAgICBlYyA9IE5PVF9T VVBQT1JURURfRVJSOwogICAgICAgICByZXR1cm47CiAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaCBiL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLmgKaW5kZXggMTljY2RkYmE1Mzgw N2UwYjBhMWNjNjRkZjg0M2JiZWM1NGUxMTY4Zi4uYzI0NmNhODJhOTY5ODBmYTdkYTkzYTc5MzY4 ZmM3MmU2MzdkODQ3MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0 cmVhbS9NZWRpYURldmljZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3Ry ZWFtL01lZGlhRGV2aWNlcy5oCkBAIC01NSw4ICs1NSw4IEBAIHB1YmxpYzoKIAogICAgIERvY3Vt ZW50KiBkb2N1bWVudCgpIGNvbnN0OwogCi0gICAgdHlwZWRlZiBzdGQ6OmZ1bmN0aW9uPHZvaWQo UmVmUHRyPE1lZGlhU3RyZWFtPik+IFJlc29sdmVDYWxsYmFjazsKLSAgICB0eXBlZGVmIHN0ZDo6 ZnVuY3Rpb248dm9pZChSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+KT4gUmVqZWN0Q2Fs bGJhY2s7CisgICAgdHlwZWRlZiBzdGQ6OmZ1bmN0aW9uPHZvaWQoTWVkaWFTdHJlYW0qKT4gUmVz b2x2ZUNhbGxiYWNrOworICAgIHR5cGVkZWYgc3RkOjpmdW5jdGlvbjx2b2lkKE5hdmlnYXRvclVz ZXJNZWRpYUVycm9yKik+IFJlamVjdENhbGxiYWNrOwogCiAgICAgdm9pZCBnZXRVc2VyTWVkaWEo Y29uc3QgRGljdGlvbmFyeSYsIFJlc29sdmVDYWxsYmFjaywgUmVqZWN0Q2FsbGJhY2ssIEV4Y2Vw dGlvbkNvZGUmKSBjb25zdDsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9t ZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv bWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHAKaW5kZXggNGE5YWU2M2U1MWI3MWVkZTcw ZGFiMzQ0MjZhMzBlMjBmNTUzNjgyOC4uNGUyNDYyYmM5NDhhMDA3MjMwMjYxOThjYjYwYzAwNGY0 OTE2OWMzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9V c2VyTWVkaWFSZXF1ZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3Ry ZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwCkBAIC03NSwxMiArNzUsMTIgQEAgUGFzc1JlZlB0cjxV c2VyTWVkaWFSZXF1ZXN0PiBVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9u Q29udGV4dCogY28KIHsKICAgICBBU1NFUlQoc3VjY2Vzc0NhbGxiYWNrKTsKIAotICAgIGF1dG8g cmVzb2x2ZUNhbGxiYWNrID0gW3N1Y2Nlc3NDYWxsYmFja10oUmVmUHRyPE1lZGlhU3RyZWFtPiBz dHJlYW0pIG11dGFibGUgewotICAgICAgICBzdWNjZXNzQ2FsbGJhY2stPmhhbmRsZUV2ZW50KHN0 cmVhbS5nZXQoKSk7CisgICAgYXV0byByZXNvbHZlQ2FsbGJhY2sgPSBbc3VjY2Vzc0NhbGxiYWNr XShNZWRpYVN0cmVhbSogc3RyZWFtKSBtdXRhYmxlIHsKKyAgICAgICAgc3VjY2Vzc0NhbGxiYWNr LT5oYW5kbGVFdmVudChzdHJlYW0pOwogICAgIH07Ci0gICAgYXV0byByZWplY3RDYWxsYmFjayA9 IFtlcnJvckNhbGxiYWNrXShSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+IGVycm9yKSBt dXRhYmxlIHsKKyAgICBhdXRvIHJlamVjdENhbGxiYWNrID0gW2Vycm9yQ2FsbGJhY2tdKE5hdmln YXRvclVzZXJNZWRpYUVycm9yKiBlcnJvcikgbXV0YWJsZSB7CiAgICAgICAgIGlmIChlcnJvckNh bGxiYWNrKQotICAgICAgICAgICAgZXJyb3JDYWxsYmFjay0+aGFuZGxlRXZlbnQoZXJyb3IuZ2V0 KCkpOworICAgICAgICAgICAgZXJyb3JDYWxsYmFjay0+aGFuZGxlRXZlbnQoZXJyb3IpOwogICAg IH07CiAKICAgICByZXR1cm4gVXNlck1lZGlhUmVxdWVzdDo6Y3JlYXRlKGNvbnRleHQsIGNvbnRy b2xsZXIsIG9wdGlvbnMsIFdURjo6bW92ZShyZXNvbHZlQ2FsbGJhY2spLCBXVEY6Om1vdmUocmVq ZWN0Q2FsbGJhY2spLCBlYyk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9q cy9KU01lZGlhRGV2aWNlc0N1c3RvbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9K U01lZGlhRGV2aWNlc0N1c3RvbS5jcHAKaW5kZXggZTQwMWFiMGQwYjE4NjM5MmYyZTFiNGZhMjY2 ZDlkMTc2MDIzNDljOS4uZjM1M2QyZGEyNmQ4ODZjYTRhM2Y1MTk0ZjJkMjUzYWY1YWZlMjEyNiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNNZWRpYURldmljZXNDdXN0 b20uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTTWVkaWFEZXZpY2VzQ3Vz dG9tLmNwcApAQCAtNDYsMjkgKzQ2LDMxIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogSlNWYWx1 ZSBKU01lZGlhRGV2aWNlczo6Z2V0VXNlck1lZGlhKEV4ZWNTdGF0ZSogZXhlYykKIHsKKyAgICBE ZWZlcnJlZFdyYXBwZXIgd3JhcHBlcihleGVjLCBnbG9iYWxPYmplY3QoKSk7CisKICAgICBEaWN0 aW9uYXJ5IG9wdGlvbnMoZXhlYywgZXhlYy0+YXJndW1lbnQoMCkpOwotICAgIGlmIChleGVjLT5o YWRFeGNlcHRpb24oKSkKLSAgICAgICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7CisgICAgaWYgKGV4 ZWMtPmhhZEV4Y2VwdGlvbigpKSB7CisgICAgICAgIHdyYXBwZXIucmVqZWN0KGV4ZWMtPmV4Y2Vw dGlvbigpKTsKKyAgICAgICAgcmV0dXJuIHdyYXBwZXIucHJvbWlzZSgpOworICAgIH0KIAogICAg IGlmICghb3B0aW9ucy5pc09iamVjdCgpKSB7Ci0gICAgICAgIHRocm93Vk1FcnJvcihleGVjLCBj cmVhdGVUeXBlRXJyb3IoZXhlYywgIkZpcnN0IGFyZ3VtZW50IG9mIGdldFVzZXJNZWRpYSBtdXN0 IGJlIGEgdmFsaWQgRGljdGlvbmFyeSIpKTsKLSAgICAgICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7 CisgICAgICAgIEpTVmFsdWUgZXJyb3IgPSBjcmVhdGVUeXBlRXJyb3IoZXhlYywgIkZpcnN0IGFy Z3VtZW50IG9mIGdldFVzZXJNZWRpYSBtdXN0IGJlIGEgdmFsaWQgRGljdGlvbmFyeSIpOworICAg ICAgICB3cmFwcGVyLnJlamVjdChlcnJvcik7CisgICAgICAgIHJldHVybiB3cmFwcGVyLnByb21p c2UoKTsKICAgICB9CiAKLSAgICBEZWZlcnJlZFdyYXBwZXIgd3JhcHBlcihleGVjLCBnbG9iYWxP YmplY3QoKSk7Ci0gICAgYXV0byByZXNvbHZlQ2FsbGJhY2sgPSBbd3JhcHBlcl0oUmVmUHRyPE1l ZGlhU3RyZWFtPiBzdHJlYW0pIG11dGFibGUgewotICAgICAgICB3cmFwcGVyLnJlc29sdmUoc3Ry ZWFtLmdldCgpKTsKKyAgICBhdXRvIHJlc29sdmVDYWxsYmFjayA9IFt3cmFwcGVyXShNZWRpYVN0 cmVhbSogc3RyZWFtKSBtdXRhYmxlIHsKKyAgICAgICAgd3JhcHBlci5yZXNvbHZlKHN0cmVhbSk7 CiAgICAgfTsKLSAgICBhdXRvIHJlamVjdENhbGxiYWNrID0gW3dyYXBwZXJdKFJlZlB0cjxOYXZp Z2F0b3JVc2VyTWVkaWFFcnJvcj4gZXJyb3IpIG11dGFibGUgewotICAgICAgICB3cmFwcGVyLnJl amVjdChlcnJvci5nZXQoKSk7CisgICAgYXV0byByZWplY3RDYWxsYmFjayA9IFt3cmFwcGVyXShO YXZpZ2F0b3JVc2VyTWVkaWFFcnJvciogZXJyb3IpIG11dGFibGUgeworICAgICAgICB3cmFwcGVy LnJlamVjdChlcnJvcik7CiAgICAgfTsKIAogICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOwogICAg IGltcGwoKS5nZXRVc2VyTWVkaWEob3B0aW9ucywgV1RGOjptb3ZlKHJlc29sdmVDYWxsYmFjayks IFdURjo6bW92ZShyZWplY3RDYWxsYmFjayksIGVjKTsKLSAgICBpZiAoZWMpIHsKLSAgICAgICAg c2V0RE9NRXhjZXB0aW9uKGV4ZWMsIGVjKTsKLSAgICAgICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7 Ci0gICAgfQorICAgIGlmIChlYykKKyAgICAgICAgd3JhcHBlci5yZWplY3QoZWMpOwogCiAgICAg cmV0dXJuIHdyYXBwZXIucHJvbWlzZSgpOwogfQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDRiZjg5YmRiN2ZjZGQ1NmQ2Y2Uy NjlhYzAyNTg5ZDg1OTdkNzkzODQuLmQyNmRiMjI5ZjNlYTk1NjRiODZlYWNjOTUzYmEwNjY5ZDI3 MGY2MmMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxNS0wNS0yMiAgWW91ZW5uIEZhYmxldCAg PHlvdWVubi5mYWJsZXRAY3JmLmNhbm9uLmZyPgorCisgICAgICAgIE1lZGlhRGV2aWNlcy5nZXRV c2VyTWVkaWEgc2hvdWxkIHJlamVjdCBwcm9taXNlIGluc3RlYWQgb2YgdGhyb3dpbmcgZXhjZXB0 aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ1 MjgyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVXBk YXRpbmcgdGVzdCB0byBleHBlY3QgcmVqZWN0aW9uIGFuZCBub3QgZXJyb3IgdGhyb3dpbmcuCisK KyAgICAgICAgKiBmYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy1nZXRVc2VyTWVkaWEtZXhw ZWN0ZWQudHh0OgorICAgICAgICAqIGZhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVz ZXJNZWRpYS5odG1sOgorCiAyMDE1LTA1LTIwICBKb3NlcGggUGVjb3Jhcm8gIDxwZWNvcmFyb0Bh cHBsZS5jb20+CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogYXJyYXkgcHJldmlld3Mgc2hvdWxk IGhhdmUgYSBtdWNoIHNtYWxsZXIgY2FwIG9uIHZhbHVlcwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMtZ2V0VXNlck1lZGlhLWV4cGVjdGVkLnR4 dCBiL0xheW91dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVzZXJNZWRp YS1leHBlY3RlZC50eHQKaW5kZXggYjVhZTgxYjI1NDkyM2E2NDVjMmYyNmYwMzgwZGYyYWM0Yjlm MTk5Mi4uZTA1OWUzMWNlMGMzOWY5ZjRkZTdlYzg1NTFjOWE0MDM2MTI5ZGE1MyAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvZmFzdC9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMtZ2V0VXNlck1lZGlh LWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2 aWNlcy1nZXRVc2VyTWVkaWEtZXhwZWN0ZWQudHh0CkBAIC0zLDEwICszLDEwIEBAIFRlc3RzIGdl dFVzZXJNZWRpYSAoUHJvbWlzZS1iYXNlZCB2ZXJzaW9uIG9uIG5hdmlnYXRvci5tZWRpYURldmlj ZXMpCiBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2Vz LCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCiAKIAotUEFTUyBuYXZpZ2F0b3IubWVkaWFE ZXZpY2VzLmdldFVzZXJNZWRpYSgpOyB0aHJldyBleGNlcHRpb24gVHlwZUVycm9yOiBGaXJzdCBh cmd1bWVudCBvZiBnZXRVc2VyTWVkaWEgbXVzdCBiZSBhIHZhbGlkIERpY3Rpb25hcnkuCi1QQVNT IG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHt9KTsgdGhyZXcgZXhjZXB0aW9u IEVycm9yOiBOb3RTdXBwb3J0ZWRFcnJvcjogRE9NIEV4Y2VwdGlvbiA5LgotUEFTUyBuYXZpZ2F0 b3IubWVkaWFEZXZpY2VzLndlYmtpdEdldFVzZXJNZWRpYSh7YXVkaW86dHJ1ZX0pOyB0aHJldyBl eGNlcHRpb24gVHlwZUVycm9yOiBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLndlYmtpdEdldFVzZXJN ZWRpYSBpcyBub3QgYSBmdW5jdGlvbi4gKEluICduYXZpZ2F0b3IubWVkaWFEZXZpY2VzLndlYmtp dEdldFVzZXJNZWRpYSh7YXVkaW86dHJ1ZX0pJywgJ25hdmlnYXRvci5tZWRpYURldmljZXMud2Vi a2l0R2V0VXNlck1lZGlhJyBpcyB1bmRlZmluZWQpLgorUEFTUyB0eXBlb2YgbmF2aWdhdG9yLm1l ZGlhRGV2aWNlcy53ZWJraXRHZXRVc2VyTWVkaWEgaXMgJ3VuZGVmaW5lZCcKIFBBU1MgbmF2aWdh dG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOnRydWV9KS50aGVuKGdvdFN0cmVh bTEpOyBkaWQgbm90IHRocm93IGV4Y2VwdGlvbi4KK1BBU1MgbmF2aWdhdG9yLm1lZGlhRGV2aWNl cy5nZXRVc2VyTWVkaWEoKSByZWplY3RlZCB3aXRoIGVycm9yOiBUeXBlRXJyb3I6IEZpcnN0IGFy Z3VtZW50IG9mIGdldFVzZXJNZWRpYSBtdXN0IGJlIGEgdmFsaWQgRGljdGlvbmFyeQorUEFTUyAg bmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe30pIHJlamVjdGVkIHdpdGggZXJy b3I6IEVycm9yOiBOb3RTdXBwb3J0ZWRFcnJvcjogRE9NIEV4Y2VwdGlvbiA5CiBQQVNTIFN0cmVh bSBnZW5lcmF0ZWQuCiBQQVNTIHN0cmVhbS5nZXRBdWRpb1RyYWNrcygpLmxlbmd0aCBpcyAxCiBQ QVNTIHN0cmVhbS5nZXRWaWRlb1RyYWNrcygpLmxlbmd0aCBpcyAwCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy1nZXRVc2VyTWVkaWEuaHRtbCBi L0xheW91dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVzZXJNZWRpYS5o dG1sCmluZGV4IDgwNjUwMTUzYmQwNjQzOGE1ZDk0Zjk0YTk5MTc2Y2MxYjBhZmE4ZWQuLjA3ZTgx ZTUxYzQ2NmI3ZTFiODBkYWY2MDRiNjhjNmM1NWE5Zjc1MmIgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVzZXJNZWRpYS5odG1sCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVzZXJNZWRpYS5o dG1sCkBAIC03NSw5ICs3NSwxMyBAQAogICAgICAgICAgICAgICAgIHNob3VsZE5vdFRocm93KCJu YXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7dmlkZW86dHJ1ZX0pLnRoZW4oZ290 U3RyZWFtMik7IikKICAgICAgICAgICAgIH0KIAotICAgICAgICAgICAgc2hvdWxkVGhyb3coIm5h dmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKCk7Iik7Ci0gICAgICAgICAgICBzaG91 bGRUaHJvdygibmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe30pOyIpOwotICAg ICAgICAgICAgc2hvdWxkVGhyb3coIm5hdmlnYXRvci5tZWRpYURldmljZXMud2Via2l0R2V0VXNl ck1lZGlhKHthdWRpbzp0cnVlfSk7Iik7CisgICAgICAgICAgICBuYXZpZ2F0b3IubWVkaWFEZXZp Y2VzLmdldFVzZXJNZWRpYSgpLnRoZW4oaW52YWxpZEdvdFN0cmVhbSwgZnVuY3Rpb24oZXJyb3Ip IHsKKyAgICAgICAgICAgICAgICB0ZXN0UGFzc2VkKCJuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdl dFVzZXJNZWRpYSgpIHJlamVjdGVkIHdpdGggZXJyb3I6ICIgKyBlcnJvcik7CisgICAgICAgICAg ICB9KTsKKyAgICAgICAgICAgIG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHt9 KS50aGVuKGludmFsaWRHb3RTdHJlYW0sIGZ1bmN0aW9uKGVycm9yKSB7CisgICAgICAgICAgICAg ICAgdGVzdFBhc3NlZCgiIG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHt9KSBy ZWplY3RlZCB3aXRoIGVycm9yOiAiICsgZXJyb3IpOworICAgICAgICAgICAgfSk7CisgICAgICAg ICAgICBzaG91bGRCZSgidHlwZW9mIG5hdmlnYXRvci5tZWRpYURldmljZXMud2Via2l0R2V0VXNl ck1lZGlhIiwgIid1bmRlZmluZWQnIik7CiAgICAgICAgICAgICBzZXRVc2VyTWVkaWFQZXJtaXNz aW9uKHRydWUpOwogICAgICAgICAgICAgc2hvdWxkTm90VGhyb3coIm5hdmlnYXRvci5tZWRpYURl dmljZXMuZ2V0VXNlck1lZGlhKHthdWRpbzp0cnVlfSkudGhlbihnb3RTdHJlYW0xKTsiKTsKIAo= 253858 2015-05-28 13:26:39 -0700 2015-05-29 01:10:20 -0700 Patch for landing bug-145282-20150528222622.patch text/plain 10896 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTg0ODU0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOTkwMWIzZWZjNjRhNDM0 MzI0MzY3NTJlMjMwNWQwMDI1NjQ2N2U0Ni4uYWRlOTQ2MDMxOWQ1Y2RmZTg4MTgwZjllOGVkMTEz NThmMWFlNDMxNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDE1LTA1LTI3ICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgTWVkaWFE ZXZpY2VzLmdldFVzZXJNZWRpYSBzaG91bGQgcmVqZWN0IHByb21pc2UgaW5zdGVhZCBvZiB0aHJv d2luZyBleGNlcHRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xNDUyODIKKworICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KKworICAg ICAgICBFbnN1cmluZyBhdCB0aGUgY3VzdG9tIGJpbmRpbmcgbGV2ZWwgdGhhdCBhbGwgcG90ZW50 aWFsIGVycm9ycyBhcmUgdXNlZCB0byByZWplY3QgcHJvbWlzZS4KKyAgICAgICAgQ2xlYW5lZCB1 cCB0aGUgd3JhcHBlcnMgYnkgcmVtb3ZpbmcgdW5uZWVkZWQgUmVmUHRyLgorCisgICAgICAgIENv dmVyZWQgYnkgbW9kaWZpZWQgdGVzdC4KKworICAgICAgICAqIE1vZHVsZXMvbWVkaWFzdHJlYW0v TWVkaWFEZXZpY2VzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhRGV2aWNlczo6Z2V0VXNl ck1lZGlhKToKKyAgICAgICAgKiBNb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5oOgor ICAgICAgICAqIE1vZHVsZXMvbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUpOgorICAgICAgICAqIGJpbmRp bmdzL2pzL0pTTWVkaWFEZXZpY2VzQ3VzdG9tLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkpTTWVk aWFEZXZpY2VzOjpnZXRVc2VyTWVkaWEpOgorCiAyMDE1LTA1LTI2ICBZb3Vlbm4gRmFibGV0ICA8 eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CiAKICAgICAgICAgQmluZGluZyBnZW5lcmF0b3Ig c2hvdWxkIHN1cHBvcnQgaW50ZXJmYWNlcyB3aXRoIEN1c3RvbUNvbnN0cnVjdG9yIGFuZCBOb0lu dGVyZmFjZU9iamVjdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0 cmVhbS9NZWRpYURldmljZXMuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVh bS9NZWRpYURldmljZXMuY3BwCmluZGV4IDBlNzYwZDk3YmRkZjQ0MGZkODVlZmMxOWE5Njc2OWY2 M2Q2MDBiYmQuLjAyZmJjODY0Y2JhNjMwOGJmOGFiYmYzMjIxZGViODk3OWQ1NDVkMzYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5j cHAKQEAgLTY0LDYgKzY0LDcgQEAgdm9pZCBNZWRpYURldmljZXM6OmdldFVzZXJNZWRpYShjb25z dCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBSZXNvbHZlQ2FsbGJhY2sgcmVzb2wKIHsKICAgICBVc2Vy TWVkaWFDb250cm9sbGVyKiB1c2VyTWVkaWEgPSBVc2VyTWVkaWFDb250cm9sbGVyOjpmcm9tKGRv Y3VtZW50KCkgPyBkb2N1bWVudCgpLT5wYWdlKCkgOiBudWxscHRyKTsKICAgICBpZiAoIXVzZXJN ZWRpYSkgeworICAgICAgICAvLyBGSVhNRTogV2UgcHJvYmFibHkgd2FudCB0byByZXR1cm4gYSBN ZWRpYVN0cmVhbUVycm9yIGhlcmUgdXNpbmcgdGhlIHJlamVjdENhbGxiYWNrLCBhbmQgZ2V0IHJp ZCBvZmYgdGhlIEV4Y2VwdGlvbkNvZGUgcGFyYW1ldGVyLgogICAgICAgICBlYyA9IE5PVF9TVVBQ T1JURURfRVJSOwogICAgICAgICByZXR1cm47CiAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaCBiL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLmgKaW5kZXggMTljY2RkYmE1MzgwN2Uw YjBhMWNjNjRkZjg0M2JiZWM1NGUxMTY4Zi4uNzRhNzgxYzY0ZTNjMmYwMTY2NGYxMWIxOTY0NDVi ZjkzNmM4Y2RmMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVh bS9NZWRpYURldmljZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFt L01lZGlhRGV2aWNlcy5oCkBAIC01NSw4ICs1NSw4IEBAIHB1YmxpYzoKIAogICAgIERvY3VtZW50 KiBkb2N1bWVudCgpIGNvbnN0OwogCi0gICAgdHlwZWRlZiBzdGQ6OmZ1bmN0aW9uPHZvaWQoUmVm UHRyPE1lZGlhU3RyZWFtPik+IFJlc29sdmVDYWxsYmFjazsKLSAgICB0eXBlZGVmIHN0ZDo6ZnVu Y3Rpb248dm9pZChSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+KT4gUmVqZWN0Q2FsbGJh Y2s7CisgICAgdHlwZWRlZiBzdGQ6OmZ1bmN0aW9uPHZvaWQoTWVkaWFTdHJlYW0mKT4gUmVzb2x2 ZUNhbGxiYWNrOworICAgIHR5cGVkZWYgc3RkOjpmdW5jdGlvbjx2b2lkKE5hdmlnYXRvclVzZXJN ZWRpYUVycm9yJik+IFJlamVjdENhbGxiYWNrOwogCiAgICAgdm9pZCBnZXRVc2VyTWVkaWEoY29u c3QgRGljdGlvbmFyeSYsIFJlc29sdmVDYWxsYmFjaywgUmVqZWN0Q2FsbGJhY2ssIEV4Y2VwdGlv bkNvZGUmKSBjb25zdDsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRp YXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVk aWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHAKaW5kZXggNGE5YWU2M2U1MWI3MWVkZTcwZGFi MzQ0MjZhMzBlMjBmNTUzNjgyOC4uMTJjMGM2MDM4ZDIzZjkyY2M3ZTkyOTc3MjRmNjhhNTcxZjhk NmY1YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9Vc2Vy TWVkaWFSZXF1ZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFt L1VzZXJNZWRpYVJlcXVlc3QuY3BwCkBAIC03NSwxMiArNzUsMTIgQEAgUGFzc1JlZlB0cjxVc2Vy TWVkaWFSZXF1ZXN0PiBVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCogY28KIHsKICAgICBBU1NFUlQoc3VjY2Vzc0NhbGxiYWNrKTsKIAotICAgIGF1dG8gcmVz b2x2ZUNhbGxiYWNrID0gW3N1Y2Nlc3NDYWxsYmFja10oUmVmUHRyPE1lZGlhU3RyZWFtPiBzdHJl YW0pIG11dGFibGUgewotICAgICAgICBzdWNjZXNzQ2FsbGJhY2stPmhhbmRsZUV2ZW50KHN0cmVh bS5nZXQoKSk7CisgICAgYXV0byByZXNvbHZlQ2FsbGJhY2sgPSBbc3VjY2Vzc0NhbGxiYWNrXShN ZWRpYVN0cmVhbSYgc3RyZWFtKSBtdXRhYmxlIHsKKyAgICAgICAgc3VjY2Vzc0NhbGxiYWNrLT5o YW5kbGVFdmVudCgmc3RyZWFtKTsKICAgICB9OwotICAgIGF1dG8gcmVqZWN0Q2FsbGJhY2sgPSBb ZXJyb3JDYWxsYmFja10oUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yPiBlcnJvcikgbXV0 YWJsZSB7CisgICAgYXV0byByZWplY3RDYWxsYmFjayA9IFtlcnJvckNhbGxiYWNrXShOYXZpZ2F0 b3JVc2VyTWVkaWFFcnJvciYgZXJyb3IpIG11dGFibGUgewogICAgICAgICBpZiAoZXJyb3JDYWxs YmFjaykKLSAgICAgICAgICAgIGVycm9yQ2FsbGJhY2stPmhhbmRsZUV2ZW50KGVycm9yLmdldCgp KTsKKyAgICAgICAgICAgIGVycm9yQ2FsbGJhY2stPmhhbmRsZUV2ZW50KCZlcnJvcik7CiAgICAg fTsKIAogICAgIHJldHVybiBVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUoY29udGV4dCwgY29udHJv bGxlciwgb3B0aW9ucywgV1RGOjptb3ZlKHJlc29sdmVDYWxsYmFjayksIFdURjo6bW92ZShyZWpl Y3RDYWxsYmFjayksIGVjKTsKQEAgLTE3Nyw3ICsxNzcsNyBAQCB2b2lkIFVzZXJNZWRpYVJlcXVl c3Q6OmRpZENyZWF0ZVN0cmVhbShQYXNzUmVmUHRyPE1lZGlhU3RyZWFtUHJpdmF0ZT4gcHJpdmF0 ZVN0cgogICAgICAgICBmb3IgKGF1dG8mIHRyYWNrIDogc3RyZWFtLT5nZXRWaWRlb1RyYWNrcygp KQogICAgICAgICAgICAgdHJhY2stPmFwcGx5Q29uc3RyYWludHMocHJvdGVjdGVkVGhpcy0+bV92 aWRlb0NvbnN0cmFpbnRzKTsKIAotICAgICAgICBwcm90ZWN0ZWRUaGlzLT5tX3Jlc29sdmVDYWxs YmFjayhzdHJlYW0uZ2V0KCkpOworICAgICAgICBwcm90ZWN0ZWRUaGlzLT5tX3Jlc29sdmVDYWxs YmFjaygqc3RyZWFtKTsKICAgICB9KTsKIH0KIApAQCAtMTkwLDcgKzE5MCw3IEBAIHZvaWQgVXNl ck1lZGlhUmVxdWVzdDo6ZmFpbGVkVG9DcmVhdGVTdHJlYW1XaXRoQ29uc3RyYWludHNFcnJvcihj b25zdCBTdHJpbmcmIGNvCiAgICAgUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IHByb3RlY3RlZFRo aXModGhpcyk7CiAgICAgUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yPiBlcnJvciA9IE5h dmlnYXRvclVzZXJNZWRpYUVycm9yOjpjcmVhdGUoTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OmNv bnN0cmFpbnROb3RTYXRpc2ZpZWRFcnJvck5hbWUoKSwgY29uc3RyYWludE5hbWUpOwogICAgIGNh bGxPbk1haW5UaHJlYWQoW3Byb3RlY3RlZFRoaXMsIGVycm9yXSB7Ci0gICAgICAgIHByb3RlY3Rl ZFRoaXMtPm1fcmVqZWN0Q2FsbGJhY2soZXJyb3IuZ2V0KCkpOworICAgICAgICBwcm90ZWN0ZWRU aGlzLT5tX3JlamVjdENhbGxiYWNrKCplcnJvcik7CiAgICAgfSk7CiB9CiAKQEAgLTIwMyw3ICsy MDMsNyBAQCB2b2lkIFVzZXJNZWRpYVJlcXVlc3Q6OmZhaWxlZFRvQ3JlYXRlU3RyZWFtV2l0aFBl cm1pc3Npb25FcnJvcigpCiAgICAgLy8gRklYTUU6IFJlcGxhY2UgTmF2aWdhdG9yVXNlck1lZGlh RXJyb3Igd2l0aCBNZWRpYVN0cmVhbUVycm9yIChzZWUgYnVnIDE0MzMzNSkKICAgICBSZWZQdHI8 TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+IGVycm9yID0gTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6 OmNyZWF0ZShOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6cGVybWlzc2lvbkRlbmllZEVycm9yTmFt ZSgpLCBlbXB0eVN0cmluZygpKTsKICAgICBjYWxsT25NYWluVGhyZWFkKFtwcm90ZWN0ZWRUaGlz LCBlcnJvcl0gewotICAgICAgICBwcm90ZWN0ZWRUaGlzLT5tX3JlamVjdENhbGxiYWNrKGVycm9y LmdldCgpKTsKKyAgICAgICAgcHJvdGVjdGVkVGhpcy0+bV9yZWplY3RDYWxsYmFjaygqZXJyb3Ip OwogICAgIH0pOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9K U01lZGlhRGV2aWNlc0N1c3RvbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU01l ZGlhRGV2aWNlc0N1c3RvbS5jcHAKaW5kZXggZTQwMWFiMGQwYjE4NjM5MmYyZTFiNGZhMjY2ZDlk MTc2MDIzNDljOS4uOTExNDlkODAyYWMzMWQ5MzY2NmU4MjMzNTZmNzk2Y2NhNTY1ZDFjNiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNNZWRpYURldmljZXNDdXN0b20u Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTTWVkaWFEZXZpY2VzQ3VzdG9t LmNwcApAQCAtNDYsMjkgKzQ2LDMxIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogSlNWYWx1ZSBK U01lZGlhRGV2aWNlczo6Z2V0VXNlck1lZGlhKEV4ZWNTdGF0ZSogZXhlYykKIHsKKyAgICBEZWZl cnJlZFdyYXBwZXIgd3JhcHBlcihleGVjLCBnbG9iYWxPYmplY3QoKSk7CisKICAgICBEaWN0aW9u YXJ5IG9wdGlvbnMoZXhlYywgZXhlYy0+YXJndW1lbnQoMCkpOwotICAgIGlmIChleGVjLT5oYWRF eGNlcHRpb24oKSkKLSAgICAgICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7CisgICAgaWYgKGV4ZWMt PmhhZEV4Y2VwdGlvbigpKSB7CisgICAgICAgIHdyYXBwZXIucmVqZWN0KGV4ZWMtPmV4Y2VwdGlv bigpKTsKKyAgICAgICAgcmV0dXJuIHdyYXBwZXIucHJvbWlzZSgpOworICAgIH0KIAogICAgIGlm ICghb3B0aW9ucy5pc09iamVjdCgpKSB7Ci0gICAgICAgIHRocm93Vk1FcnJvcihleGVjLCBjcmVh dGVUeXBlRXJyb3IoZXhlYywgIkZpcnN0IGFyZ3VtZW50IG9mIGdldFVzZXJNZWRpYSBtdXN0IGJl IGEgdmFsaWQgRGljdGlvbmFyeSIpKTsKLSAgICAgICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7Cisg ICAgICAgIEpTVmFsdWUgZXJyb3IgPSBjcmVhdGVUeXBlRXJyb3IoZXhlYywgIkZpcnN0IGFyZ3Vt ZW50IG9mIGdldFVzZXJNZWRpYSBtdXN0IGJlIGEgdmFsaWQgRGljdGlvbmFyeSIpOworICAgICAg ICB3cmFwcGVyLnJlamVjdChlcnJvcik7CisgICAgICAgIHJldHVybiB3cmFwcGVyLnByb21pc2Uo KTsKICAgICB9CiAKLSAgICBEZWZlcnJlZFdyYXBwZXIgd3JhcHBlcihleGVjLCBnbG9iYWxPYmpl Y3QoKSk7Ci0gICAgYXV0byByZXNvbHZlQ2FsbGJhY2sgPSBbd3JhcHBlcl0oUmVmUHRyPE1lZGlh U3RyZWFtPiBzdHJlYW0pIG11dGFibGUgewotICAgICAgICB3cmFwcGVyLnJlc29sdmUoc3RyZWFt LmdldCgpKTsKKyAgICBhdXRvIHJlc29sdmVDYWxsYmFjayA9IFt3cmFwcGVyXShNZWRpYVN0cmVh bSYgc3RyZWFtKSBtdXRhYmxlIHsKKyAgICAgICAgd3JhcHBlci5yZXNvbHZlKCZzdHJlYW0pOwog ICAgIH07Ci0gICAgYXV0byByZWplY3RDYWxsYmFjayA9IFt3cmFwcGVyXShSZWZQdHI8TmF2aWdh dG9yVXNlck1lZGlhRXJyb3I+IGVycm9yKSBtdXRhYmxlIHsKLSAgICAgICAgd3JhcHBlci5yZWpl Y3QoZXJyb3IuZ2V0KCkpOworICAgIGF1dG8gcmVqZWN0Q2FsbGJhY2sgPSBbd3JhcHBlcl0oTmF2 aWdhdG9yVXNlck1lZGlhRXJyb3ImIGVycm9yKSBtdXRhYmxlIHsKKyAgICAgICAgd3JhcHBlci5y ZWplY3QoJmVycm9yKTsKICAgICB9OwogCiAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAgICAg aW1wbCgpLmdldFVzZXJNZWRpYShvcHRpb25zLCBXVEY6Om1vdmUocmVzb2x2ZUNhbGxiYWNrKSwg V1RGOjptb3ZlKHJlamVjdENhbGxiYWNrKSwgZWMpOwotICAgIGlmIChlYykgewotICAgICAgICBz ZXRET01FeGNlcHRpb24oZXhlYywgZWMpOwotICAgICAgICByZXR1cm4ganNVbmRlZmluZWQoKTsK LSAgICB9CisgICAgaWYgKGVjKQorICAgICAgICB3cmFwcGVyLnJlamVjdChlYyk7CiAKICAgICBy ZXR1cm4gd3JhcHBlci5wcm9taXNlKCk7CiB9CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggZmNiNTExMjM5ZWYyZmU4ZGM1NDdk NWE5NzUyYTU5OGUwOTVhZmIwYy4uYjJlZTU4NmQ0ZTVlYTExNWMzNmJhYzQ3MDQzZTNlOWZjNDg0 MTlmNiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3Rz L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDE1LTA1LTI3ICBZb3Vlbm4gRmFibGV0ICA8 eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgTWVkaWFEZXZpY2VzLmdldFVz ZXJNZWRpYSBzaG91bGQgcmVqZWN0IHByb21pc2UgaW5zdGVhZCBvZiB0aHJvd2luZyBleGNlcHRp b25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNDUy ODIKKworICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KKworICAgICAgICBVcGRhdGlu ZyB0ZXN0IHRvIGV4cGVjdCByZWplY3Rpb24gYW5kIG5vdCBlcnJvciB0aHJvd2luZy4KKworICAg ICAgICAqIGZhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVzZXJNZWRpYS1leHBlY3Rl ZC50eHQ6CisgICAgICAgICogZmFzdC9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMtZ2V0VXNlck1l ZGlhLmh0bWw6CisKIDIwMTUtMDUtMjUgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBp Z2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIEVuYWJsZSBJbmRleGVkREIKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVzZXJNZWRpYS1l eHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy1n ZXRVc2VyTWVkaWEtZXhwZWN0ZWQudHh0CmluZGV4IGI1YWU4MWIyNTQ5MjNhNjQ1YzJmMjZmMDM4 MGRmMmFjNGI5ZjE5OTIuLmUwNTllMzFjZTBjMzlmOWY0ZGU3ZWM4NTUxYzlhNDAzNjEyOWRhNTMg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdl dFVzZXJNZWRpYS1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9tZWRpYXN0cmVh bS9NZWRpYURldmljZXMtZ2V0VXNlck1lZGlhLWV4cGVjdGVkLnR4dApAQCAtMywxMCArMywxMCBA QCBUZXN0cyBnZXRVc2VyTWVkaWEgKFByb21pc2UtYmFzZWQgdmVyc2lvbiBvbiBuYXZpZ2F0b3Iu bWVkaWFEZXZpY2VzKQogT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNT IiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgogCiAKLVBBU1MgbmF2aWdh dG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoKTsgdGhyZXcgZXhjZXB0aW9uIFR5cGVFcnJv cjogRmlyc3QgYXJndW1lbnQgb2YgZ2V0VXNlck1lZGlhIG11c3QgYmUgYSB2YWxpZCBEaWN0aW9u YXJ5LgotUEFTUyBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7fSk7IHRocmV3 IGV4Y2VwdGlvbiBFcnJvcjogTm90U3VwcG9ydGVkRXJyb3I6IERPTSBFeGNlcHRpb24gOS4KLVBB U1MgbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy53ZWJraXRHZXRVc2VyTWVkaWEoe2F1ZGlvOnRydWV9 KTsgdGhyZXcgZXhjZXB0aW9uIFR5cGVFcnJvcjogbmF2aWdhdG9yLm1lZGlhRGV2aWNlcy53ZWJr aXRHZXRVc2VyTWVkaWEgaXMgbm90IGEgZnVuY3Rpb24uIChJbiAnbmF2aWdhdG9yLm1lZGlhRGV2 aWNlcy53ZWJraXRHZXRVc2VyTWVkaWEoe2F1ZGlvOnRydWV9KScsICduYXZpZ2F0b3IubWVkaWFE ZXZpY2VzLndlYmtpdEdldFVzZXJNZWRpYScgaXMgdW5kZWZpbmVkKS4KK1BBU1MgdHlwZW9mIG5h dmlnYXRvci5tZWRpYURldmljZXMud2Via2l0R2V0VXNlck1lZGlhIGlzICd1bmRlZmluZWQnCiBQ QVNTIG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHthdWRpbzp0cnVlfSkudGhl bihnb3RTdHJlYW0xKTsgZGlkIG5vdCB0aHJvdyBleGNlcHRpb24uCitQQVNTIG5hdmlnYXRvci5t ZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKCkgcmVqZWN0ZWQgd2l0aCBlcnJvcjogVHlwZUVycm9y OiBGaXJzdCBhcmd1bWVudCBvZiBnZXRVc2VyTWVkaWEgbXVzdCBiZSBhIHZhbGlkIERpY3Rpb25h cnkKK1BBU1MgIG5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHt9KSByZWplY3Rl ZCB3aXRoIGVycm9yOiBFcnJvcjogTm90U3VwcG9ydGVkRXJyb3I6IERPTSBFeGNlcHRpb24gOQog UEFTUyBTdHJlYW0gZ2VuZXJhdGVkLgogUEFTUyBzdHJlYW0uZ2V0QXVkaW9UcmFja3MoKS5sZW5n dGggaXMgMQogUEFTUyBzdHJlYW0uZ2V0VmlkZW9UcmFja3MoKS5sZW5ndGggaXMgMApkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMtZ2V0VXNlck1l ZGlhLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy1nZXRV c2VyTWVkaWEuaHRtbAppbmRleCA4MDY1MDE1M2JkMDY0MzhhNWQ5NGY5NGE5OTE3NmNjMWIwYWZh OGVkLi4wN2U4MWU1MWM0NjZiN2UxYjgwZGFmNjA0YjY4YzZjNTVhOWY3NTJiIDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9mYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy1nZXRVc2VyTWVkaWEu aHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy1nZXRV c2VyTWVkaWEuaHRtbApAQCAtNzUsOSArNzUsMTMgQEAKICAgICAgICAgICAgICAgICBzaG91bGRO b3RUaHJvdygibmF2aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe3ZpZGVvOnRydWV9 KS50aGVuKGdvdFN0cmVhbTIpOyIpCiAgICAgICAgICAgICB9CiAKLSAgICAgICAgICAgIHNob3Vs ZFRocm93KCJuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSgpOyIpOwotICAgICAg ICAgICAgc2hvdWxkVGhyb3coIm5hdmlnYXRvci5tZWRpYURldmljZXMuZ2V0VXNlck1lZGlhKHt9 KTsiKTsKLSAgICAgICAgICAgIHNob3VsZFRocm93KCJuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLndl YmtpdEdldFVzZXJNZWRpYSh7YXVkaW86dHJ1ZX0pOyIpOworICAgICAgICAgICAgbmF2aWdhdG9y Lm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoKS50aGVuKGludmFsaWRHb3RTdHJlYW0sIGZ1bmN0 aW9uKGVycm9yKSB7CisgICAgICAgICAgICAgICAgdGVzdFBhc3NlZCgibmF2aWdhdG9yLm1lZGlh RGV2aWNlcy5nZXRVc2VyTWVkaWEoKSByZWplY3RlZCB3aXRoIGVycm9yOiAiICsgZXJyb3IpOwor ICAgICAgICAgICAgfSk7CisgICAgICAgICAgICBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVz ZXJNZWRpYSh7fSkudGhlbihpbnZhbGlkR290U3RyZWFtLCBmdW5jdGlvbihlcnJvcikgeworICAg ICAgICAgICAgICAgIHRlc3RQYXNzZWQoIiBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJN ZWRpYSh7fSkgcmVqZWN0ZWQgd2l0aCBlcnJvcjogIiArIGVycm9yKTsKKyAgICAgICAgICAgIH0p OworICAgICAgICAgICAgc2hvdWxkQmUoInR5cGVvZiBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLndl YmtpdEdldFVzZXJNZWRpYSIsICIndW5kZWZpbmVkJyIpOwogICAgICAgICAgICAgc2V0VXNlck1l ZGlhUGVybWlzc2lvbih0cnVlKTsKICAgICAgICAgICAgIHNob3VsZE5vdFRocm93KCJuYXZpZ2F0 b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSh7YXVkaW86dHJ1ZX0pLnRoZW4oZ290U3RyZWFt MSk7Iik7CiAK