185370 2018-05-06 21:48:22 -0700 WKPageSetMediaVolume() API couldn't be used to restore the volume 2018-05-11 03:32:29 -0700 1 1 1 Unclassified WebKit WebKit API Other Unspecified Unspecified NEW P2 Normal --- 1 vivek_arumugam calvaris calvaris eric.carlson ews-watchlist jer.noble pvollan ramasamy_thalavaypillai rniwa vivek_arumugam youennf oldest_to_newest 1421212 0 339705 vivek_arumugam 2018-05-06 21:48:22 -0700 Created attachment 339705 . The WKPageSetMediaVolume() API takes a floating point input ranging 0-1 which is used as a multiplier against all the media elements of a page thus acts as a master volume control. But however the current implementation doesn't maintain the actual volume set from the upper layers (i.e JS / Media Player App) so every time UI Process calls this API the internal volume gets only reduced thus preventing us to get the previous volume back. Result is this API can't be used to temporarily reduce and restore the volume on demand. An example scenario is : * Assume initial volume of HTMLMediaElement is 0.9 & the multiplier (page::mediaVolume()) is 1 (Media player plays with full volume) * Do WKPageSetMediaVolume(xyz, 0.5) * page::mediaVolume() = 0.5 * HTMLMediaPlayer's m_volume is updated as (m_volume = 0.9 * page->mediaVolume = 0.5) = 0.45 * Do WKPageSetMediaVolume(xyz, 1) * page::mediaVolume() = 1 * HTMLMediaPlayer's m_volume is updated as (m_volume = 0.45 * page->mediaVolume = 1) = 0.45 (volume is still 0.45) And call WKPageSetMediaVolume(xyz, 0.5) again then the volume gets reduced even lower. I guess this is not the intended behavior. I was trying to fix this with the below patchset. 1421225 1 ews-watchlist 2018-05-07 01:15:13 -0700 Attachment 339705 did not pass style-queue: ERROR: Source/WebCore/html/HTMLMediaElement.cpp:4819: Missing space before ( in if( [whitespace/parens] [5] Total errors found: 1 in 2 files If any of these errors are false positives, please file a bug against check-webkit-style. 1421226 2 calvaris 2018-05-07 01:16:57 -0700 (In reply to Vivek Arumugam from comment #0) > The WKPageSetMediaVolume() API takes a floating point input ranging 0-1 > which is used as a multiplier against all the media elements of a page thus > acts as a master volume control. But however the current implementation > doesn't maintain the actual volume set from the upper layers (i.e JS / Media > Player App) so every time UI Process calls this API the internal volume gets > only reduced thus preventing us to get the previous volume back. Result is > this API can't be used to temporarily reduce and restore the volume on > demand. Yes, as we discussed in private, we'd need Dimm and UnDimm API that goes from the WebKit API layer down to the HTMLMediaElement. In the HTMLMediaElement or the MediaPlayer we would keep the former volume and when Dimming and restore it without multiplying when UnDimming. 1421252 3 vivek_arumugam 2018-05-07 04:25:13 -0700 Introducing another set of APIs to reduce and restore the volume might be redundant and requires few assumptions as below: 1) If we are to have an API to Dim the volume do we need to pass any value / should we assume that it should reduce the volume to 25% or someother value? 2) And if we are to pass some value, again, we can't be passing any absolute value from UI Process because at that moment the media players (from different documents) from the same page might have different volumes. This argument supports the use of factored/multiplier approach as WKPageSetMediaVolume(). If we are worried about breaking existing functionality of WKPageSetMediaVolume(), we should first confirm that the purpose of WKPageSetMediaVolume() is different than what I think it is. 1421253 4 calvaris 2018-05-07 04:51:38 -0700 (In reply to Vivek Arumugam from comment #3) > 1) If we are to have an API to Dim the volume do we need to pass any value / > should we assume that it should reduce the volume to 25% or someother value? IMHO, it should take a value. > 2) And if we are to pass some value, again, we can't be passing any absolute > value from UI Process because at that moment the media players (from > different documents) from the same page might have different volumes. This > argument supports the use of factored/multiplier approach as > WKPageSetMediaVolume(). This value would reduce the volume as it is done for WKPageSetMediaVolume but it would be recoverable after with UnDimm. > If we are worried about breaking existing functionality of > WKPageSetMediaVolume(), we should first confirm that the purpose of > WKPageSetMediaVolume() is different than what I think it is. We need to consider this, yes. If a set is made while the volume is dimmed, we need to deal with it somehow, either by failing or ignoring the set or by failing/ignoring the undimm. 1421261 5 eric.carlson 2018-05-07 06:38:46 -0700 (In reply to Xabier Rodríguez Calvar from comment #4) > (In reply to Vivek Arumugam from comment #3) > > 2) And if we are to pass some value, again, we can't be passing any absolute > > value from UI Process because at that moment the media players (from > > different documents) from the same page might have different volumes. This > > argument supports the use of factored/multiplier approach as > > WKPageSetMediaVolume(). > > This value would reduce the volume as it is done for WKPageSetMediaVolume > but it would be recoverable after with UnDimm. > > > If we are worried about breaking existing functionality of > > WKPageSetMediaVolume(), we should first confirm that the purpose of > > WKPageSetMediaVolume() is different than what I think it is. > > We need to consider this, yes. If a set is made while the volume is dimmed, > we need to deal with it somehow, either by failing or ignoring the set or by > failing/ignoring the undimm. I would prefer to fix the existing API if possible instead of introducing a new one. The proposed change will not break any usage I am aware of. 1421262 6 339705 eric.carlson 2018-05-07 06:42:08 -0700 Comment on attachment 339705 . View in context: https://bugs.webkit.org/attachment.cgi?id=339705&action=review > Source/WebCore/html/HTMLMediaElement.h:969 > + double m_refVolume { 1 }; There is no need to abbreviate: m_referenceVolume. 1421265 7 339715 vivek_arumugam 2018-05-07 06:56:15 -0700 Created attachment 339715 . Addressed comments, please review. 1422187 8 339715 calvaris 2018-05-09 01:10:27 -0700 Comment on attachment 339715 . View in context: https://bugs.webkit.org/attachment.cgi?id=339715&action=review We can't land this as it does not have ChangeLog. > Source/WebCore/html/HTMLMediaElement.cpp:4820 > + Page* page = document().page(); > + if (!page || page->mediaVolume() == 1) > + m_referenceVolume = vol; I see a big problem with this code. Let's think of this use case: 1. m_volume = 1; m_referenceVolume = 1; page->m_mediaVolume = 1; 2. setPageMediaVolume(0.5); -> m_volume = 0.5; m_referenceVolume = 1; page->m_mediaVolume = 0.5; 3. Lower the stream volume to 0.25 -> m_volume = 0.25; m_referenceVolume = 1; page->m_mediaVolume = 0.5; 4. setPageMediaVolume(1); -> m_volume = 1; m_referenceVolume = 1; page->m_mediaVolume = 1; Step 4 is a problem, because you lowered the volume to almost nothing and then the set page volume ramps it up to 1 when the user had lowered the volume to 0.25. Eric, I think this behavior is wrong. We should consider, at least, m_referenceVolume to scale as if page volume were always 1 since we are already multiplying it with the volumeMultiplier when going back down to the player. If we go for this solution, we should, IMHO, instead of this code, do: m_referenceVolume = m_volume; if (page) m_referenceVolume /= page->mediaVolume(); And if we accept my premise, we could even consider m_referenceVolume to be redundant and consider that m_volume is always scaled with reference to the page being 1. If we consider this alternative, we might want to touch HTMLMediaElement::setReadyState and HTMLMediaElement::volume() to correct with the page volume or we would be getting lots of tests failing. We might just change HTMLMediaElement::volume() and have HTMLMediaElement::setReadyState using HTMLMediaElement::volume(). I would also add a couple of comments in m_volume and HTMLMediaElement::volume() regarding this. 1422194 9 339945 calvaris 2018-05-09 01:24:22 -0700 Created attachment 339945 Patch I think this is a better solution for the issue we have here. 1422196 10 vivek_arumugam 2018-05-09 01:31:35 -0700 (In reply to Xabier Rodríguez Calvar from comment #8) > Comment on attachment 339715 [details] > . > > View in context: > https://bugs.webkit.org/attachment.cgi?id=339715&action=review > > We can't land this as it does not have ChangeLog. > > > Source/WebCore/html/HTMLMediaElement.cpp:4820 > > + Page* page = document().page(); > > + if (!page || page->mediaVolume() == 1) > > + m_referenceVolume = vol; > > I see a big problem with this code. Let's think of this use case: > > 1. m_volume = 1; m_referenceVolume = 1; page->m_mediaVolume = 1; > 2. setPageMediaVolume(0.5); -> m_volume = 0.5; m_referenceVolume = 1; > page->m_mediaVolume = 0.5; > 3. Lower the stream volume to 0.25 -> m_volume = 0.25; m_referenceVolume = > 1; page->m_mediaVolume = 0.5; > 4. setPageMediaVolume(1); -> m_volume = 1; m_referenceVolume = 1; > page->m_mediaVolume = 1; > > Step 4 is a problem, because you lowered the volume to almost nothing and > then the set page volume ramps it up to 1 when the user had lowered the > volume to 0.25. > > Eric, I think this behavior is wrong. We should consider, at least, > m_referenceVolume to scale as if page volume were always 1 since we are > already multiplying it with the volumeMultiplier when going back down to the > player. If we go for this solution, we should, IMHO, instead of this code, > do: > m_referenceVolume = m_volume; > if (page) > m_referenceVolume /= page->mediaVolume(); > > And if we accept my premise, we could even consider m_referenceVolume to be > redundant and consider that m_volume is always scaled with reference to the > page being 1. If we consider this alternative, we might want to touch > HTMLMediaElement::setReadyState and HTMLMediaElement::volume() to correct > with the page volume or we would be getting lots of tests failing. We might > just change HTMLMediaElement::volume() and have > HTMLMediaElement::setReadyState using HTMLMediaElement::volume(). I would > also add a couple of comments in m_volume and HTMLMediaElement::volume() > regarding this. Hi Calvaris, Thank you for the review. I would like to know what do you mean by step 3? Which code flow is that? If you mean HTMLMediaElement::setVolume() the m_referenceVolume too gets updated with m_volume. Please clarify. 1422199 11 calvaris 2018-05-09 01:45:40 -0700 (In reply to Vivek Arumugam from comment #10) > Hi Calvaris, Thank you for the review. I would like to know what do you mean > by step 3? Which code flow is that? If you mean > HTMLMediaElement::setVolume() the m_referenceVolume too gets updated with > m_volume. Please clarify. Volume can be updated through pulseaudio or other volume managers so we would still get callbacks for those changes which would end up in a situation like step 3. 1422275 12 339945 eric.carlson 2018-05-09 08:58:33 -0700 Comment on attachment 339945 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=339945&action=review > Source/WebCore/html/HTMLMediaElement.cpp:3634 > + Page* page = document().page(); Nit: auto* page = ... > Source/WebCore/html/HTMLMediaElement.cpp:3657 > + Page* page = document().page(); > + if (page) > + m_volume /= page->mediaVolume(); > + if (m_mediaController) > + m_volume /= m_mediaController->volume(); > +#if ENABLE(MEDIA_SESSION) > + if (m_shouldDuck) > + m_volume /= 0.25; > +#endif This is identical to the code in volume(), it should be shared. > Source/WebCore/html/HTMLMediaElement.cpp:3658 > + m_volume = CLAMP(m_volume, 0.0, 1.0); You can use clampToFloat() from MathExtras.h > Source/WebCore/html/HTMLMediaElement.cpp:3675 > + setScaledVolume(newVolume); setScaledVolume() will redo the same calculations just done in the call to volume() above. If setScaledVolume() returned a bool if the volume doesn't new volume is identical to the current volume, you could use it above and only do the calculations once. > Source/WebCore/html/HTMLMediaElement.cpp:4841 > + if (vol != volume()) { > + setScaledVolume(vol); Ditto. > Source/WebCore/html/HTMLMediaElement.cpp:5243 > + if (volume() != volume) { > + setScaledVolume(volume); Ditto. > Source/WebCore/html/HTMLMediaElement.cpp:5252 > + Page* page = document().page(); Nit: auto* page = ... > Source/WebCore/html/HTMLMediaElement.cpp:5257 > + m_player->setVolume(volume()); Why calculate the volume again, won't m_volume be correct after the call to setScaledVolume()? 1422276 13 eric.carlson 2018-05-09 09:00:03 -0700 (In reply to Xabier Rodríguez Calvar from comment #8) > Comment on attachment 339715 [details] > > I see a big problem with this code. Let's think of this use case: > > 1. m_volume = 1; m_referenceVolume = 1; page->m_mediaVolume = 1; > 2. setPageMediaVolume(0.5); -> m_volume = 0.5; m_referenceVolume = 1; > page->m_mediaVolume = 0.5; > 3. Lower the stream volume to 0.25 -> m_volume = 0.25; m_referenceVolume = > 1; page->m_mediaVolume = 0.5; > 4. setPageMediaVolume(1); -> m_volume = 1; m_referenceVolume = 1; > page->m_mediaVolume = 1; > > Step 4 is a problem, because you lowered the volume to almost nothing and > then the set page volume ramps it up to 1 when the user had lowered the > volume to 0.25. > > Eric, I think this behavior is wrong. Good point, thanks for thinking this through! 1422685 14 calvaris 2018-05-10 02:31:58 -0700 (In reply to Eric Carlson from comment #12) > > Source/WebCore/html/HTMLMediaElement.cpp:3634 > > + Page* page = document().page(); > > Nit: auto* page = ... Roger. > > Source/WebCore/html/HTMLMediaElement.cpp:3657 > > + Page* page = document().page(); > > + if (page) > > + m_volume /= page->mediaVolume(); > > + if (m_mediaController) > > + m_volume /= m_mediaController->volume(); > > +#if ENABLE(MEDIA_SESSION) > > + if (m_shouldDuck) > > + m_volume /= 0.25; > > +#endif > > This is identical to the code in volume(), it should be shared. No, one multiplies, the other divides. > > Source/WebCore/html/HTMLMediaElement.cpp:3658 > > + m_volume = CLAMP(m_volume, 0.0, 1.0); > > You can use clampToFloat() from MathExtras.h Roger. > > Source/WebCore/html/HTMLMediaElement.cpp:3675 > > + setScaledVolume(newVolume); > > setScaledVolume() will redo the same calculations just done in the call to > volume() above. If setScaledVolume() returned a bool if the volume doesn't > new volume is identical to the current volume, you could use it above and > only do the calculations once. I can work try to work this out. > > Source/WebCore/html/HTMLMediaElement.cpp:5257 > > + m_player->setVolume(volume()); > > Why calculate the volume again, won't m_volume be correct after the call to > setScaledVolume()? No, the idea was that in the HTMLMediaElement, we kept the volume unscaled from the Page and then, when committing to the player, we could apply the scale. 1423104 15 calvaris 2018-05-11 03:32:00 -0700 Eric: Vivek and I had private conversations about the results of this patch and the truth is that it does not work either. Let's see: | Operation | Page | Element | Player | |--------------------------:|-----:|---------:|-------:| | Init | 1 | 1 | 1 | | Element::setVolume(0.7) | 1 | 0.7 | 0.7 | | Page::setMediaVolume(0.1) | 0.1 | 0.7 | 0.07 | | Element::setVolume(0.25) | 0.1 | 2.5 -> 1 | 1 | What I tried to do with the patch was trying to decouple the player volume and the element volume so that we could recover the player volume when resetting the page volume. The problem is that HTMLMediaElement::setVolume should respect the volume of the player (and so should setting it through any other API, like pulseaudio), which didn't happen with my patch leading to situations like the one here. If we consider the page multiplier as it was, we always go down when we change it and we can't recover from that. If we try to keep the different scales, we can get out of them and screw up. We could consider the multiplier the first time, keep the same scale between player and element but again we wouldn't be able to recover and the page scale would be out of sync. My opinion on what we should do to fix the current mess is consider the Page::setMediaVolume a one time only thing. The page decides to scale the volume? Fine, we do it and forget. That volume change would be translated to element and player but if JS, the element controls or external entities (of course I talk about non-IOS devices) decide to ramp up the volume, they could. Always respecting the page volume would mean that we'd have to reduce the scale in our volume controls, meaning that if page volume is set to 50%, volume would have to move between 0..50% and we'd have to find a way to deal with volumes higher than that set by JS or set by external volume controls. JS could be easier, we clamp to page volume and we can be happy, but external controls would be another issue because we can't set the scale there, you would drag that volume bar and see it coming down to the page volume, which would be weird. Then we still have the problem of Dimming and UnDimming the volume and the only solution I can think of to do this properly would be a Dimm and UnDimm API. Dimm would keep the page volume in the element and UnDimm would undo the dimming if the volume has not been touched by hand in any other control. 339705 2018-05-06 21:48:22 -0700 2018-05-08 00:17:17 -0700 . webkit_master_volume_control.diff text/plain 2017 vivek_arumugam ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAgYi9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwCmluZGV4IDk2Y2Y4YjliMTRh Li5mNmQxMGRjMGM4MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFF bGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3Bw CkBAIC0zNjQ4LDYgKzM2NDgsNyBAQCBFeGNlcHRpb25Pcjx2b2lkPiBIVE1MTWVkaWFFbGVtZW50 OjpzZXRWb2x1bWUoZG91YmxlIHZvbHVtZSkKICAgICAgICAgcmVtb3ZlQmVoYXZpb3JzUmVzdHJp Y3Rpb25zQWZ0ZXJGaXJzdFVzZXJHZXN0dXJlKE1lZGlhRWxlbWVudFNlc3Npb246OkFsbFJlc3Ry aWN0aW9ucyAmIH5NZWRpYUVsZW1lbnRTZXNzaW9uOjpSZXF1aXJlVXNlckdlc3R1cmVUb0NvbnRy b2xDb250cm9sc01hbmFnZXIpOwogCiAgICAgbV92b2x1bWUgPSB2b2x1bWU7CisgICAgbV9yZWZW b2x1bWUgPSBtX3ZvbHVtZTsKICAgICBtX3ZvbHVtZUluaXRpYWxpemVkID0gdHJ1ZTsKICAgICB1 cGRhdGVWb2x1bWUoKTsKICAgICBzY2hlZHVsZUV2ZW50KGV2ZW50TmFtZXMoKS52b2x1bWVjaGFu Z2VFdmVudCk7CkBAIC00ODE0LDYgKzQ4MTUsOSBAQCB2b2lkIEhUTUxNZWRpYUVsZW1lbnQ6Om1l ZGlhUGxheWVyVm9sdW1lQ2hhbmdlZChNZWRpYVBsYXllciopCiAgICAgICAgIGRvdWJsZSB2b2wg PSBtX3BsYXllci0+dm9sdW1lKCk7CiAgICAgICAgIGlmICh2b2wgIT0gbV92b2x1bWUpIHsKICAg ICAgICAgICAgIG1fdm9sdW1lID0gdm9sOworICAgICAgICAgICAgUGFnZSogcGFnZSA9IGRvY3Vt ZW50KCkucGFnZSgpOworICAgICAgICAgICAgaWYoIXBhZ2UgfHwgcGFnZS0+bWVkaWFWb2x1bWUo KSA9PSAxKQorICAgICAgICAgICAgICAgIG1fcmVmVm9sdW1lID0gdm9sOwogICAgICAgICAgICAg dXBkYXRlVm9sdW1lKCk7CiAgICAgICAgICAgICBzY2hlZHVsZUV2ZW50KGV2ZW50TmFtZXMoKS52 b2x1bWVjaGFuZ2VFdmVudCk7CiAgICAgICAgIH0KQEAgLTUyMTYsNiArNTIyMCw3IEBAIHZvaWQg SFRNTE1lZGlhRWxlbWVudDo6dXBkYXRlVm9sdW1lKCkKICAgICBmbG9hdCB2b2x1bWUgPSBtX3Bs YXllci0+dm9sdW1lKCk7CiAgICAgaWYgKG1fdm9sdW1lICE9IHZvbHVtZSkgewogICAgICAgICBt X3ZvbHVtZSA9IHZvbHVtZTsKKyAgICAgICAgbV9yZWZWb2x1bWUgPSB2b2x1bWU7CiAgICAgICAg IHNjaGVkdWxlRXZlbnQoZXZlbnROYW1lcygpLnZvbHVtZWNoYW5nZUV2ZW50KTsKICAgICB9CiAj ZWxzZQpAQCAtNTIzNiw3ICs1MjQxLDcgQEAgdm9pZCBIVE1MTWVkaWFFbGVtZW50Ojp1cGRhdGVW b2x1bWUoKQogI2VuZGlmCiAKICAgICAgICAgbV9wbGF5ZXItPnNldE11dGVkKHNob3VsZE11dGUp OwotICAgICAgICBtX3BsYXllci0+c2V0Vm9sdW1lKG1fdm9sdW1lICogdm9sdW1lTXVsdGlwbGll cik7CisgICAgICAgIG1fcGxheWVyLT5zZXRWb2x1bWUobV9yZWZWb2x1bWUgKiB2b2x1bWVNdWx0 aXBsaWVyKTsKICAgICB9CiAKICNpZiBFTkFCTEUoTUVESUFfU0VTU0lPTikKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MTWVkaWFFbGVtZW50LmgKaW5kZXggYmE5ZjU5YTc3YzIuLjU1ZjFhZmEyN2I1IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuaApAQCAtOTY2LDYgKzk2Niw3IEBA IHByaXZhdGU6CiAgICAgU2Vla1R5cGUgbV9wZW5kaW5nU2Vla1R5cGUgeyBOb1NlZWsgfTsKIAog ICAgIGRvdWJsZSBtX3ZvbHVtZSB7IDEgfTsKKyAgICBkb3VibGUgbV9yZWZWb2x1bWUgeyAxIH07 CiAgICAgYm9vbCBtX3ZvbHVtZUluaXRpYWxpemVkIHsgZmFsc2UgfTsKICAgICBNZWRpYVRpbWUg bV9sYXN0U2Vla1RpbWU7CiAgICAgCg== 339715 2018-05-07 06:56:15 -0700 2018-05-09 01:24:02 -0700 . webkit_master_volume_control-02.diff text/plain 2048 vivek_arumugam ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAgYi9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwCmluZGV4IDk2Y2Y4YjliMTRh Li5hZTE1NWZiOGM0YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFF bGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3Bw CkBAIC0zNjQ4LDYgKzM2NDgsNyBAQCBFeGNlcHRpb25Pcjx2b2lkPiBIVE1MTWVkaWFFbGVtZW50 OjpzZXRWb2x1bWUoZG91YmxlIHZvbHVtZSkKICAgICAgICAgcmVtb3ZlQmVoYXZpb3JzUmVzdHJp Y3Rpb25zQWZ0ZXJGaXJzdFVzZXJHZXN0dXJlKE1lZGlhRWxlbWVudFNlc3Npb246OkFsbFJlc3Ry aWN0aW9ucyAmIH5NZWRpYUVsZW1lbnRTZXNzaW9uOjpSZXF1aXJlVXNlckdlc3R1cmVUb0NvbnRy b2xDb250cm9sc01hbmFnZXIpOwogCiAgICAgbV92b2x1bWUgPSB2b2x1bWU7CisgICAgbV9yZWZl cmVuY2VWb2x1bWUgPSBtX3ZvbHVtZTsKICAgICBtX3ZvbHVtZUluaXRpYWxpemVkID0gdHJ1ZTsK ICAgICB1cGRhdGVWb2x1bWUoKTsKICAgICBzY2hlZHVsZUV2ZW50KGV2ZW50TmFtZXMoKS52b2x1 bWVjaGFuZ2VFdmVudCk7CkBAIC00ODE0LDYgKzQ4MTUsOSBAQCB2b2lkIEhUTUxNZWRpYUVsZW1l bnQ6Om1lZGlhUGxheWVyVm9sdW1lQ2hhbmdlZChNZWRpYVBsYXllciopCiAgICAgICAgIGRvdWJs ZSB2b2wgPSBtX3BsYXllci0+dm9sdW1lKCk7CiAgICAgICAgIGlmICh2b2wgIT0gbV92b2x1bWUp IHsKICAgICAgICAgICAgIG1fdm9sdW1lID0gdm9sOworICAgICAgICAgICAgUGFnZSogcGFnZSA9 IGRvY3VtZW50KCkucGFnZSgpOworICAgICAgICAgICAgaWYgKCFwYWdlIHx8IHBhZ2UtPm1lZGlh Vm9sdW1lKCkgPT0gMSkKKyAgICAgICAgICAgICAgICBtX3JlZmVyZW5jZVZvbHVtZSA9IHZvbDsK ICAgICAgICAgICAgIHVwZGF0ZVZvbHVtZSgpOwogICAgICAgICAgICAgc2NoZWR1bGVFdmVudChl dmVudE5hbWVzKCkudm9sdW1lY2hhbmdlRXZlbnQpOwogICAgICAgICB9CkBAIC01MjE2LDYgKzUy MjAsNyBAQCB2b2lkIEhUTUxNZWRpYUVsZW1lbnQ6OnVwZGF0ZVZvbHVtZSgpCiAgICAgZmxvYXQg dm9sdW1lID0gbV9wbGF5ZXItPnZvbHVtZSgpOwogICAgIGlmIChtX3ZvbHVtZSAhPSB2b2x1bWUp IHsKICAgICAgICAgbV92b2x1bWUgPSB2b2x1bWU7CisgICAgICAgIG1fcmVmZXJlbmNlVm9sdW1l ID0gdm9sdW1lOwogICAgICAgICBzY2hlZHVsZUV2ZW50KGV2ZW50TmFtZXMoKS52b2x1bWVjaGFu Z2VFdmVudCk7CiAgICAgfQogI2Vsc2UKQEAgLTUyMzYsNyArNTI0MSw3IEBAIHZvaWQgSFRNTE1l ZGlhRWxlbWVudDo6dXBkYXRlVm9sdW1lKCkKICNlbmRpZgogCiAgICAgICAgIG1fcGxheWVyLT5z ZXRNdXRlZChzaG91bGRNdXRlKTsKLSAgICAgICAgbV9wbGF5ZXItPnNldFZvbHVtZShtX3ZvbHVt ZSAqIHZvbHVtZU11bHRpcGxpZXIpOworICAgICAgICBtX3BsYXllci0+c2V0Vm9sdW1lKG1fcmVm ZXJlbmNlVm9sdW1lICogdm9sdW1lTXVsdGlwbGllcik7CiAgICAgfQogCiAjaWYgRU5BQkxFKE1F RElBX1NFU1NJT04pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVs ZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5oCmluZGV4IGJh OWY1OWE3N2MyLi41ZDA5ZTZmOTRmZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MTWVkaWFFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVt ZW50LmgKQEAgLTk2Niw2ICs5NjYsNyBAQCBwcml2YXRlOgogICAgIFNlZWtUeXBlIG1fcGVuZGlu Z1NlZWtUeXBlIHsgTm9TZWVrIH07CiAKICAgICBkb3VibGUgbV92b2x1bWUgeyAxIH07CisgICAg ZG91YmxlIG1fcmVmZXJlbmNlVm9sdW1lIHsgMSB9OwogICAgIGJvb2wgbV92b2x1bWVJbml0aWFs aXplZCB7IGZhbHNlIH07CiAgICAgTWVkaWFUaW1lIG1fbGFzdFNlZWtUaW1lOwogICAgIAo= 339945 2018-05-09 01:24:22 -0700 2018-05-11 03:32:29 -0700 Patch bug-185370-20180509102421.patch text/plain 6456 calvaris U3VidmVyc2lvbiBSZXZpc2lvbjogMjMxNDgyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOTk3OGY5NjhhMDlhNmU5 NWYxMmJmYzgxMWM0NzExZjdkNTk1MWQ1Ny4uNGU5MTc1ZTk1N2RhZjBkZDgxZTg2ZTNiYjkzYTNk NjJhMWE3MDE3YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDE4LTA1LTA5ICBYYWJp ZXIgUm9kcmlndWV6IENhbHZhciAgPGNhbHZhcmlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgV0tQ YWdlU2V0TWVkaWFWb2x1bWUoKSBBUEkgY291bGRuJ3QgYmUgdXNlZCB0byByZXN0b3JlIHRoZSB2 b2x1bWUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4 NTM3MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRo ZSBwcm9ibGVtIGhhcHBlbnMgd2hlbiB0aGUgbXVsdGlwbGllciBnb2VzIGRvd24gdG8gdGhlIHBs YXllcgorICAgICAgICBhbmQgY29tZXMgYmFjayBhZnRlciB0aGUgdm9sdW1lIGlzIHNldCwgdGhh dCB2b2x1bWUgaXMgc2V0IGFzIHRoZQorICAgICAgICBlbGVtZW50J3MgYW5kIGZvbGxvd2luZyBj YWxscyB0byB0aGF0IHdvbid0IGJlIGFibGUgdG8gcmVjb3ZlcgorICAgICAgICBpdC4gVGhpcyBw YXRjaCBjaGFuZ2VzIHRoZSB2b2x1bWUgc3RvcmFnZSBpbiB0aGUgZWxlbWVudCB3aXRob3V0Cisg ICAgICAgIHRha2luZyBpbnRvIGFjY291bnQgdGhlIG11bHRpcGxpZXIuCisKKyAgICAgICAgKiBo dG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTE1lZGlhRWxl bWVudDo6dm9sdW1lIGNvbnN0KTogQ29udmVydHMgZnJvbSBpbnRlcm5hbAorICAgICAgICBub3Qg c2NhbGVkIHZvbHVtZSB0byBzY2FsZWQgdm9sdW1lLgorICAgICAgICAoV2ViQ29yZTo6SFRNTE1l ZGlhRWxlbWVudDo6c2V0U2NhbGVkVm9sdW1lKTogQ29udmVydHMgZnJvbSBzY2FsZWQKKyAgICAg ICAgdm9sdW1lIHRvIGludGVybmFsbHkgdW5zY2FsZWQuCisgICAgICAgIChXZWJDb3JlOjpIVE1M TWVkaWFFbGVtZW50OjpzZXRSZWFkeVN0YXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxNZWRp YUVsZW1lbnQ6OnNldFZvbHVtZSk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MTWVkaWFFbGVtZW50 OjptZWRpYVBsYXllclZvbHVtZUNoYW5nZWQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTE1lZGlh RWxlbWVudDo6dXBkYXRlVm9sdW1lKTogVXNlIHZvbHVtZSgpIGFuZAorICAgICAgICBzZXRTY2Fs ZWRWb2x1bWUoKS4KKyAgICAgICAgKiBodG1sL0hUTUxNZWRpYUVsZW1lbnQuaDogQWRkZWQgYSBj b21tZW50IHRvIHRoZSBtX3ZvbHVtZQorICAgICAgICBhdHRyaWJ1dGUgcmVnYXJkaW5nIHRoZSBz Y2FsZS4KKwogMjAxOC0wNS0wNyAgWmFsYW4gQnVqdGFzICA8emFsYW5AYXBwbGUuY29tPgogCiAg ICAgICAgIFtMRkNdIEFkZCBGb3JtYXR0aW5nQ29udGV4dDo6bGF5b3V0T3V0T2ZGbG93RGVzY2Vu ZGFudHMgaW1wbGVtZW50YXRpb24KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRN TE1lZGlhRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQu Y3BwCmluZGV4IDk2Y2Y4YjliMTRhMGU5MWZiNDgwZTJjZTMwM2QzNjgyYzAzZWZhMmIuLjBmZmUy MDNjZGFmNjRkNjUyZWZlMmRkNGZiYTNiOGVkNjYxNjM0YzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MTWVkaWFFbGVtZW50LmNwcApAQCAtMjUwMyw3ICsyNTAzLDcgQEAgdm9pZCBIVE1MTWVk aWFFbGVtZW50OjpzZXRSZWFkeVN0YXRlKE1lZGlhUGxheWVyOjpSZWFkeVN0YXRlIHN0YXRlKQog ICAgICAgICBpZiAoaGFzRXZlbnRMaXN0ZW5lcnMoZXZlbnROYW1lcygpLndlYmtpdHBsYXliYWNr dGFyZ2V0YXZhaWxhYmlsaXR5Y2hhbmdlZEV2ZW50KSkKICAgICAgICAgICAgIGVucXVldWVQbGF5 YmFja1RhcmdldEF2YWlsYWJpbGl0eUNoYW5nZWRFdmVudCgpOwogI2VuZGlmCi0gICAgICAgIG1f aW5pdGlhbGx5TXV0ZWQgPSBtX3ZvbHVtZSA8IDAuMDUgfHwgbXV0ZWQoKTsKKyAgICAgICAgbV9p bml0aWFsbHlNdXRlZCA9IHZvbHVtZSgpIDwgMC4wNSB8fCBtdXRlZCgpOwogCiAgICAgICAgIGlm IChoYXNNZWRpYUNvbnRyb2xzKCkpCiAgICAgICAgICAgICBtZWRpYUNvbnRyb2xzKCktPmxvYWRl ZE1ldGFkYXRhKCk7CkBAIC0zNjMwLDI0ICszNjMwLDQ5IEBAIHZvaWQgSFRNTE1lZGlhRWxlbWVu dDo6c2V0Q29udHJvbHMoYm9vbCBiKQogCiBkb3VibGUgSFRNTE1lZGlhRWxlbWVudDo6dm9sdW1l KCkgY29uc3QKIHsKLSAgICByZXR1cm4gbV92b2x1bWU7CisgICAgZG91YmxlIHZvbHVtZSA9IG1f dm9sdW1lOworICAgIFBhZ2UqIHBhZ2UgPSBkb2N1bWVudCgpLnBhZ2UoKTsKKyAgICBpZiAocGFn ZSkKKyAgICAgICAgdm9sdW1lICo9IHBhZ2UtPm1lZGlhVm9sdW1lKCk7CisgICAgaWYgKG1fbWVk aWFDb250cm9sbGVyKQorICAgICAgICB2b2x1bWUgKj0gbV9tZWRpYUNvbnRyb2xsZXItPnZvbHVt ZSgpOworI2lmIEVOQUJMRShNRURJQV9TRVNTSU9OKQorICAgIGlmIChtX3Nob3VsZER1Y2spCisg ICAgICAgIHZvbHVtZSAqPSAwLjI1OworI2VuZGlmCisgICAgcmV0dXJuIHZvbHVtZTsKK30KKwor dm9pZCBIVE1MTWVkaWFFbGVtZW50OjpzZXRTY2FsZWRWb2x1bWUoZG91YmxlIHZvbHVtZSkKK3sK KyAgICBtX3ZvbHVtZSA9IHZvbHVtZTsKKyAgICBQYWdlKiBwYWdlID0gZG9jdW1lbnQoKS5wYWdl KCk7CisgICAgaWYgKHBhZ2UpCisgICAgICAgIG1fdm9sdW1lIC89IHBhZ2UtPm1lZGlhVm9sdW1l KCk7CisgICAgaWYgKG1fbWVkaWFDb250cm9sbGVyKQorICAgICAgICBtX3ZvbHVtZSAvPSBtX21l ZGlhQ29udHJvbGxlci0+dm9sdW1lKCk7CisjaWYgRU5BQkxFKE1FRElBX1NFU1NJT04pCisgICAg aWYgKG1fc2hvdWxkRHVjaykKKyAgICAgICAgbV92b2x1bWUgLz0gMC4yNTsKKyNlbmRpZgorICAg IG1fdm9sdW1lID0gQ0xBTVAobV92b2x1bWUsIDAuMCwgMS4wKTsKIH0KIAotRXhjZXB0aW9uT3I8 dm9pZD4gSFRNTE1lZGlhRWxlbWVudDo6c2V0Vm9sdW1lKGRvdWJsZSB2b2x1bWUpCitFeGNlcHRp b25Pcjx2b2lkPiBIVE1MTWVkaWFFbGVtZW50OjpzZXRWb2x1bWUoZG91YmxlIG5ld1ZvbHVtZSkK IHsKLSAgICBJTkZPX0xPRyhMT0dJREVOVElGSUVSLCB2b2x1bWUpOworICAgIElORk9fTE9HKExP R0lERU5USUZJRVIsIG5ld1ZvbHVtZSk7CiAKLSAgICBpZiAoISh2b2x1bWUgPj0gMCAmJiB2b2x1 bWUgPD0gMSkpCisgICAgaWYgKCEobmV3Vm9sdW1lID49IDAgJiYgbmV3Vm9sdW1lIDw9IDEpKQog ICAgICAgICByZXR1cm4gRXhjZXB0aW9uIHsgSW5kZXhTaXplRXJyb3IgfTsKIAogI2lmICFQTEFU Rk9STShJT1MpCi0gICAgaWYgKG1fdm9sdW1lID09IHZvbHVtZSkKKyAgICBpZiAodm9sdW1lKCkg PT0gbmV3Vm9sdW1lKQogICAgICAgICByZXR1cm4geyB9OwogCi0gICAgaWYgKHZvbHVtZSAmJiBw cm9jZXNzaW5nVXNlckdlc3R1cmVGb3JNZWRpYSgpKQorICAgIGlmIChuZXdWb2x1bWUgJiYgcHJv Y2Vzc2luZ1VzZXJHZXN0dXJlRm9yTWVkaWEoKSkKICAgICAgICAgcmVtb3ZlQmVoYXZpb3JzUmVz dHJpY3Rpb25zQWZ0ZXJGaXJzdFVzZXJHZXN0dXJlKE1lZGlhRWxlbWVudFNlc3Npb246OkFsbFJl c3RyaWN0aW9ucyAmIH5NZWRpYUVsZW1lbnRTZXNzaW9uOjpSZXF1aXJlVXNlckdlc3R1cmVUb0Nv bnRyb2xDb250cm9sc01hbmFnZXIpOwogCi0gICAgbV92b2x1bWUgPSB2b2x1bWU7CisgICAgc2V0 U2NhbGVkVm9sdW1lKG5ld1ZvbHVtZSk7CiAgICAgbV92b2x1bWVJbml0aWFsaXplZCA9IHRydWU7 CiAgICAgdXBkYXRlVm9sdW1lKCk7CiAgICAgc2NoZWR1bGVFdmVudChldmVudE5hbWVzKCkudm9s dW1lY2hhbmdlRXZlbnQpOwpAQCAtNDgxMiw4ICs0ODM3LDggQEAgdm9pZCBIVE1MTWVkaWFFbGVt ZW50OjptZWRpYVBsYXllclZvbHVtZUNoYW5nZWQoTWVkaWFQbGF5ZXIqKQogICAgIGJlZ2luUHJv Y2Vzc2luZ01lZGlhUGxheWVyQ2FsbGJhY2soKTsKICAgICBpZiAobV9wbGF5ZXIpIHsKICAgICAg ICAgZG91YmxlIHZvbCA9IG1fcGxheWVyLT52b2x1bWUoKTsKLSAgICAgICAgaWYgKHZvbCAhPSBt X3ZvbHVtZSkgewotICAgICAgICAgICAgbV92b2x1bWUgPSB2b2w7CisgICAgICAgIGlmICh2b2wg IT0gdm9sdW1lKCkpIHsKKyAgICAgICAgICAgIHNldFNjYWxlZFZvbHVtZSh2b2wpOwogICAgICAg ICAgICAgdXBkYXRlVm9sdW1lKCk7CiAgICAgICAgICAgICBzY2hlZHVsZUV2ZW50KGV2ZW50TmFt ZXMoKS52b2x1bWVjaGFuZ2VFdmVudCk7CiAgICAgICAgIH0KQEAgLTUyMTQsMjkgKzUyMzksMjIg QEAgdm9pZCBIVE1MTWVkaWFFbGVtZW50Ojp1cGRhdGVWb2x1bWUoKQogI2lmIFBMQVRGT1JNKElP UykKICAgICAvLyBPbmx5IHRoZSB1c2VyIGNhbiBjaGFuZ2UgYXVkaW8gdm9sdW1lIHNvIHVwZGF0 ZSB0aGUgY2FjaGVkIHZvbHVtZSBhbmQgcG9zdCB0aGUgY2hhbmdlZCBldmVudC4KICAgICBmbG9h dCB2b2x1bWUgPSBtX3BsYXllci0+dm9sdW1lKCk7Ci0gICAgaWYgKG1fdm9sdW1lICE9IHZvbHVt ZSkgewotICAgICAgICBtX3ZvbHVtZSA9IHZvbHVtZTsKKyAgICBpZiAodm9sdW1lKCkgIT0gdm9s dW1lKSB7CisgICAgICAgIHNldFNjYWxlZFZvbHVtZSh2b2x1bWUpOwogICAgICAgICBzY2hlZHVs ZUV2ZW50KGV2ZW50TmFtZXMoKS52b2x1bWVjaGFuZ2VFdmVudCk7CiAgICAgfQogI2Vsc2UKICAg ICAvLyBBdm9pZCByZWN1cnNpb24gd2hlbiB0aGUgcGxheWVyIHJlcG9ydHMgdm9sdW1lIGNoYW5n ZXMuCiAgICAgaWYgKCFwcm9jZXNzaW5nTWVkaWFQbGF5ZXJDYWxsYmFjaygpKSB7Ci0gICAgICAg IFBhZ2UqIHBhZ2UgPSBkb2N1bWVudCgpLnBhZ2UoKTsKLSAgICAgICAgZG91YmxlIHZvbHVtZU11 bHRpcGxpZXIgPSBwYWdlID8gcGFnZS0+bWVkaWFWb2x1bWUoKSA6IDE7CiAgICAgICAgIGJvb2wg c2hvdWxkTXV0ZSA9IGVmZmVjdGl2ZU11dGVkKCk7CiAKICAgICAgICAgaWYgKG1fbWVkaWFDb250 cm9sbGVyKSB7Ci0gICAgICAgICAgICB2b2x1bWVNdWx0aXBsaWVyICo9IG1fbWVkaWFDb250cm9s bGVyLT52b2x1bWUoKTsKKyAgICAgICAgICAgIFBhZ2UqIHBhZ2UgPSBkb2N1bWVudCgpLnBhZ2Uo KTsKICAgICAgICAgICAgIHNob3VsZE11dGUgPSBtX21lZGlhQ29udHJvbGxlci0+bXV0ZWQoKSB8 fCAocGFnZSAmJiBwYWdlLT5pc0F1ZGlvTXV0ZWQoKSk7CiAgICAgICAgIH0KIAotI2lmIEVOQUJM RShNRURJQV9TRVNTSU9OKQotICAgICAgICBpZiAobV9zaG91bGREdWNrKQotICAgICAgICAgICAg dm9sdW1lTXVsdGlwbGllciAqPSAwLjI1OwotI2VuZGlmCi0KICAgICAgICAgbV9wbGF5ZXItPnNl dE11dGVkKHNob3VsZE11dGUpOwotICAgICAgICBtX3BsYXllci0+c2V0Vm9sdW1lKG1fdm9sdW1l ICogdm9sdW1lTXVsdGlwbGllcik7CisgICAgICAgIG1fcGxheWVyLT5zZXRWb2x1bWUodm9sdW1l KCkpOwogICAgIH0KIAogI2lmIEVOQUJMRShNRURJQV9TRVNTSU9OKQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxNZWRpYUVsZW1lbnQuaAppbmRleCBiYTlmNTlhNzdjMjdiYjllNzM4Mzk3ZTNiYWY1YWUw NjQ4YjAwNTAzLi45ZGZmN2VhZGMxYWI5ZDRkYWVmZmRhNGI0NzM4NjFkNDA5YzY0YWRiIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuaApAQCAtODE0LDYgKzgxNCw4IEBAIHBy aXZhdGU6CiAKICAgICB2b2lkIHNldFBsYXliYWNrUmF0ZUludGVybmFsKGRvdWJsZSk7CiAKKyAg ICB2b2lkIHNldFNjYWxlZFZvbHVtZShkb3VibGUpOworCiAgICAgdm9pZCBtZWRpYUNhblN0YXJ0 KERvY3VtZW50JikgZmluYWw7CiAKICAgICB2b2lkIGludmFsaWRhdGVDYWNoZWRUaW1lKCkgY29u c3Q7CkBAIC05NjUsNiArOTY3LDcgQEAgcHJpdmF0ZToKICAgICBzdGQ6OnVuaXF1ZV9wdHI8UGVu ZGluZ1NlZWs+IG1fcGVuZGluZ1NlZWs7CiAgICAgU2Vla1R5cGUgbV9wZW5kaW5nU2Vla1R5cGUg eyBOb1NlZWsgfTsKIAorICAgIC8vIFZvbHVtZSBpcyBhbHdheXMgcmVmZXJlbmNlZCB0byBjb25z aWRlcmluZyBwYWdlIHZvbHVtZSB0byBiZSAxLgogICAgIGRvdWJsZSBtX3ZvbHVtZSB7IDEgfTsK ICAgICBib29sIG1fdm9sdW1lSW5pdGlhbGl6ZWQgeyBmYWxzZSB9OwogICAgIE1lZGlhVGltZSBt X2xhc3RTZWVrVGltZTsK