94227 2012-08-16 10:45:29 -0700 Text Autosizing: Multiply large fonts less, as they are already more legible. 2012-08-23 09:23:58 -0700 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 84186 1 johnme johnme abarth aelias bruno.abinader eric jchaffraix kenneth peter satish simon.fraser tmpsantos webkit.review.bot oldest_to_newest 697267 0 johnme 2012-08-16 10:45:29 -0700 Rather than uniformly multiplying font sizes by the multiplier (derived from the width of the block), we should multiply fonts that are already large less, since they are already more legible hence there is less need for them to grow. It is still important to maintain differentiation between text that the author specified to be of different sizes. See discussion in https://bugs.webkit.org/show_bug.cgi?id=91660#c33. I've plotted a graph of some of the available options: http://fooplot.com/plot/61n34syi04 The x axis is specifiedSize, the y axis is computedSize, the blue line is what Chrome for Android uses, the red line is what Firefox for Mobile uses, and the green lines are the two alternative proposals from https://bugzilla.mozilla.org/show_bug.cgi?id=777089. All the lines except the dark green (minimum size + specified size) one eventually join onto y=x. In other words, everyone seems to agree that there's no point increasing the size of text that's already huge. The major difference between Chrome and Firefox is that when specifiedSize is 0, Chrome's computedSize is 0, whereas Firefox's computedSize is the minimum legible font size (computed using something like 13px * multiplier, so 26px if the multiplier is 2 as in the graph). The Chrome approach (disclaimer: I wrote it) seems to make more sense, since if the author chose a tiny font size, they presumably did so deliberately, presumably because that paragraph is less important. I see the role of Text Autosizing as equaling the legibility of a page on desktop (the environment it was probably designed for), but see no particular benefit to forcing all text to be some minimum size. So unless I hear arguments to the contrary, I'll probably go with the Chrome approach, where specifiedSize <= 15px gets multiplied directly by the multiplier, then above that the computedSize grows in proportion to the specifiedSize, but at a rate slower than 1:1, until the computedSize meets the computedSize=specifiedSize line, at which point it just stays on that line. 697331 1 kenneth 2012-08-16 11:53:38 -0700 Nice description. I think a minimum size makes some sense; though I am not arguing for either. Think about it, the point is that it should be possible to read text when zoomed in to just contain the container containing the text, removing the necessity to scroll horizontally (which can be difficult without undeliberately panning away from the container). Without forcing a minimum size there will be cases where you need to zoom further in in order to be able to read the text, which results in required horizontal panning. It might make sense here to consider the landscape mode. Ie. the font needs not be enlarged more than it is possible to read it in landscape mode. Maybe that is a reasonable compromise. 698141 2 johnme 2012-08-17 03:17:25 -0700 (In reply to comment #1) > I think a minimum size makes some sense; though I am not arguing for either. > > Think about it, the point is that it should be possible to read text when zoomed in to just contain the container containing the text, removing the necessity to scroll horizontally (which can be difficult without undeliberately panning away from the container). > > Without forcing a minimum size there will be cases where you need to zoom further in in order to be able to read the text, which results in required horizontal panning. But the author has chosen to make this text illegible (or hard to read) on desktop. Why should we make it more legible on mobile than on desktop? For example, say the author sets the font size of some text to 8 CSS pixels, in a block of text that is 640 CSS pixels wide on a screen that's 320 logical pixels wide. The multiplier will be 640/320=2, so with the Chrome approach we'll set the font size to 16 CSS pixels, but due to the width of the block if they fit the block to the screen they will view it at 50% size due to the zoom, so the effective font size will be 16/2 = 8 CSS pixels, i.e. exactly as legible as it would have been on desktop. > It might make sense here to consider the landscape mode. Ie. the font needs not be enlarged more than it is possible to read it in landscape mode. Maybe that is a reasonable compromise. I think it's most useful to optimize for the orientation the user has chosen to hold the device in. If it's portrait, we multiply sizes more; if it's landscape, we multiply sizes less*. Repeatedly forcing the user to rotate to landscape is not a good user experience. Based on this, I would also recommend recomputing Text Autosizing when the user rotates their device, though if some ports value pretty rotation animations over the ensuing text legibility, then I guess this could be configurable. *: This already works, since TextAutosizer::processBox sets the multiplier inversely proportional to the window width (which is greater in landscape). 698191 3 kenneth 2012-08-17 04:31:32 -0700 > For example, say the author sets the font size of some text to 8 CSS pixels, in a block of text that is 640 CSS pixels wide on a screen that's 320 logical pixels wide. The multiplier will be 640/320=2, so with the Chrome approach we'll set the font size to 16 CSS pixels, but due to the width of the block if they fit the block to the screen they will view it at 50% size due to the zoom, so the effective font size will be 16/2 = 8 CSS pixels, i.e. exactly as legible as it would have been on desktop. I am not trying to argue that the other solution is better :-) I just wanted to find some arguments for it. > Based on this, I would also recommend recomputing Text Autosizing when the user rotates their device, though if some ports value pretty rotation animations over the ensuing text legibility, then I guess this could be configurable. I think most people change the orientation as the text is too small and it requires too much effort to read it. Personally I much prefer to just use portrait. If this is indeed the case, it speaks for not treading it differently. Or always look at the actual device width and not current width. 698202 4 johnme 2012-08-17 04:46:06 -0700 (In reply to comment #3) > > Based on this, I would also recommend recomputing Text Autosizing when the user rotates their device, though if some ports value pretty rotation animations over the ensuing text legibility, then I guess this could be configurable. > > I think most people change the orientation as the text is too small and it requires too much effort to read it. Personally I much prefer to just use portrait. If this is indeed the case, it speaks for not treading it differently. Or always look at the actual device width and not current width. Like you I prefer to always use portrait, hence I think we should aim to make the portrait text big enough such that people don't need to change orientation (indeed such that there is no benefit in changing orientation, except to see more words per line). That's how it works in Chrome, Firefox and IE Mobile; it's only in Mobile Safari and the Nokia N9 browser that it's possible for the text to become too small in portrait (due to the various caps and clustering). I'm not quite sure what you mean by actual device width vs current width. If by actual device width you mean always using min(screen width, screen height) rather than using the screen width in the current orientation (which will be larger in landscape), then I disagree. Using the same multiplier in both portrait and landscape would mean that text is either too small in portrait or too large in landscape (or both). 698205 5 kenneth 2012-08-17 04:51:08 -0700 > Like you I prefer to always use portrait, hence I think we should aim to make the portrait text big enough such that people don't need to change orientation (indeed such that there is no benefit in changing orientation, except to see more words per line). That's how it works in Chrome, Firefox and IE Mobile; it's only in Mobile Safari and the Nokia N9 browser that it's possible for the text to become too small in portrait (due to the various caps and clustering). > > I'm not quite sure what you mean by actual device width vs current width. If by actual device width you mean always using min(screen width, screen height) rather than using the screen width in the current orientation (which will be larger in landscape), then I disagree. Using the same multiplier in both portrait and landscape would mean that text is either too small in portrait or too large in landscape (or both). I mean, don't change the layout when changing orientation unless the viewport info forces you to. That means everything is just scaled up in landscape (what I believe most people expect) when there are no viewport restrictions. That said, I mean that you calculate the fonts sizes as if you were always in portrait. 698435 6 159145 johnme 2012-08-17 09:56:12 -0700 Created attachment 159145 Patch This implements the algorithm from Chrome for Android, chosen for the reasons described above. 698509 7 johnme 2012-08-17 11:24:24 -0700 (In reply to comment #5) > I mean, don't change the layout when changing orientation unless the viewport info forces you to. That means everything is just scaled up in landscape (what I believe most people expect) when there are no viewport restrictions. That said, I mean that you calculate the fonts sizes as if you were always in portrait. I suspect people's expectations would adapt fairly quickly whichever approach is taken here, so we should probably decide based on which is most useful. On a phone since landscape mode AFAIK isn't much used normally (though people with less nimble fingers are more likely to prefer landscape mode since it's easier to type in), I can imagine it might indeed be useful to get bigger font sizes in landscape as you are suggesting, e.g. in cases where the user hasn't got their glasses, or is bleary-eyed in the morning, or is jogging. On tablet however landscape mode is on a more equal footing with portrait mode, so I feel it would be strange to get different font sizes. It's not clear what's best here. It also has to match how the browser rotates width=device-width viewport sites. Mobile Safari, and possibly Nokia N9 browser, prefer to just stretch the existing layout, whereas other browsers always resize it. Web developers certainly seem to prefer resizing, given the prevalence of width=device-width,initial-scale=1,maximum-scale=1 viewports used to work around this behavior and force Mobile Safari to resize it (with the unfortunate side-effect of preventing user zooming) [1]. Either way, this is orthogonal to the algorithm for mapping specifiedSizes onto computedSizes given a multiplier, so we should probably open a new bug for this :) [1]: http://www.456bereastreet.com/archive/201012/controlling_text_size_in_safari_for_ios_without_disabling_user_zoom/ 698944 8 kenneth 2012-08-18 13:56:00 -0700 > It's not clear what's best here. It also has to match how the browser rotates width=device-width viewport sites. Mobile Safari, and possibly Nokia N9 browser, prefer to just stretch the existing layout, whereas other browsers always resize it. Yes, for us device-width is the width when holding the device in its preferred orientation, ie for a phone, device-width is the width when holding the phone in portrait mode. Web authors can easily override this by not allowing changing the scale (maximum-scale=1 etc) > Web developers certainly seem to prefer resizing, given the prevalence of width=device-width,initial-scale=1,maximum-scale=1 viewports used to work around this behavior and force Mobile Safari to resize it (with the unfortunate side-effect of preventing user zooming) [1]. Yes, they usually prefer that when making web apps, because apps do that. I believe the other is a better default. The point is that per default the browser tries to show you the exact same area of content when changing orientation. Ie, I could double-tap to zoom into a column, and then change to portrait and I will see the exact same contents (width-wise). This works pretty well for pages not defining a viewport meta tag. It would be good if browsers actually handled this the same way. 699636 9 johnme 2012-08-20 10:26:13 -0700 (In reply to comment #8) > Yes, for us device-width is the width when holding the device in its preferred orientation, ie for a phone, device-width is the width when holding the phone in portrait mode. Web authors can easily override this by not allowing changing the scale (maximum-scale=1 etc) But as noted in comment #7, this has the often undesirable side-effect of preventing the user from zooming in/out (even on width=device-width pages, it can be nice to zoom in, e.g. to fit an image to the screen). > > Web developers certainly seem to prefer resizing, given the prevalence of width=device-width,initial-scale=1,maximum-scale=1 viewports used to work around this behavior and force Mobile Safari to resize it (with the unfortunate side-effect of preventing user zooming) [1]. > > Yes, they usually prefer that when making web apps, because apps do that. I believe the other is a better default. The point is that per default the browser tries to show you the exact same area of content when changing orientation. Ie, I could double-tap to zoom into a column, and then change to portrait and I will see the exact same contents (width-wise). It's not just web apps; most web pages I've seen override it too. It just doesn't make sense for everything to get 80% bigger (e.g. 854/480 = 1.78) in landscape, unless you expect the user to be holding the device almost twice as far away from their eyes, which I doubt. And showing the same content when you change orientation is still possible if you resize the viewport. It may require slightly more work by the browser, but even in the worst case if the layout changes significantly the browser could remember what block was currently centered (and how far through it you have scrolled), and make that block still be centered (and equivalently scrolled) after the orientation change. So all you really lose is the ability to so a perfectly smooth animation where you just rotate the page, which is a small price to pay in exchange for the page being much more usable after the orientation change - after all people spend much longer reading content than they do rotating their devices... > This works pretty well for pages not defining a viewport meta tag. For pages not defining a viewport meta tag this choice doesn't occur, as they'll use the same fixed width (usually 980px) in both orientations. > It would be good if browsers actually handled this the same way. Agreed. 699646 10 159469 johnme 2012-08-20 10:29:47 -0700 Created attachment 159469 Patch Rebased following the changes in bug 91660. The EWS bots should now be able to run this. The patch continues to be mainly orthogonal to the (interesting) discussion in the bug :) 700549 11 kenneth 2012-08-21 00:48:11 -0700 (In reply to comment #9) > (In reply to comment #8) > > Yes, for us device-width is the width when holding the device in its preferred orientation, ie for a phone, device-width is the width when holding the phone in portrait mode. Web authors can easily override this by not allowing changing the scale (maximum-scale=1 etc) > > But as noted in comment #7, this has the often undesirable side-effect of preventing the user from zooming in/out (even on width=device-width pages, it can be nice to zoom in, e.g. to fit an image to the screen). But on the other hand, people who want to mimic native apps don't want whole-ui zooming as that is not something that people are used to in native apps. > It's not just web apps; most web pages I've seen override it too. I think many pages override it by mistake as they don't know what they are doing and the viewport meta tag is usually ignored in desktop browsers. > It just doesn't make sense for everything to get 80% bigger (e.g. 854/480 = 1.78) in landscape, unless you expect the user to be holding the device almost twice as far away from their eyes, which I doubt. Think abuot it the other way around. You double tapped to zoom in a column, now you change from landscape to portrait, and you have to readjust the view in order to read the column. You do not need to do that on iOS or the N9. This is especially useful for desktop pages. > And showing the same content when you change orientation is still possible if you resize the viewport. It may require slightly more work by the browser, but even in the worst case if the layout changes significantly the browser could remember what block was currently centered (and how far through it you have scrolled), and make that block still be centered (and equivalently scrolled) after the orientation change. So all you really lose is the ability to so a perfectly smooth animation where you just rotate the page, which is a small price to pay in exchange for the page being much more usable after the orientation change - after all people spend much longer reading content than they do rotating their devices... It is much more complicated to do that for columns that you are zoomed into so that they fit the viewport width. Some columns might also be fixed sized (using images etc which should fix). It can probably be done, but I am afraid that there are so many corner cases which break. 700777 12 johnme 2012-08-21 08:16:22 -0700 (In reply to comment #11) > But on the other hand, people who want to mimic native apps don't want whole-ui zooming as that is not something that people are used to in native apps. Sure - those people can just use user-scalable=no. But there are bunch of well-known web developers who want user-scalable=yes for its accessibility benefits yet dislike the Safari/N9 rotation behaviour: - http://adactio.com/journal/5088/ - https://github.com/scottjehl/Device-Bugs/issues/2 - http://www.456bereastreet.com/archive/201012/controlling_text_size_in_safari_for_ios_without_disabling_user_zoom/ - https://github.com/h5bp/html5-boilerplate/issues/1099 Though according to https://twitter.com/wilto/status/212636063762628608 the Safari bug has been fixed in iOS 6, so it'll be possible to use a "width=device-width, initial-scale=1" viewport without the zoom glitching when you rotate from portrait to landscape. (In case you're wondering, I can't reproduce that exact bug on N9 if I try http://filamentgroup.com/examples/iosScaleBug/, but I do note that on http://jsbin.com/urowoh/44#device-width,scale=1 if you rotate from portrait to landscape you end up excessively zoomed in -- indeed, further than the maximum-scale allows -- which is fairly similar). > > It's not just web apps; most web pages I've seen override it too. > > I think many pages override it by mistake as they don't know what they are doing and the viewport meta tag is usually ignored in desktop browsers. While I agree that there's a lot of blind copy/pasting going on, I think the links above show that knowledgeable page authors also dislike the zooming; meanwhile I've yet to find anyone who actually likes it. > > It just doesn't make sense for everything to get 80% bigger (e.g. 854/480 = 1.78) in landscape, unless you expect the user to be holding the device almost twice as far away from their eyes, which I doubt. > > Think abuot it the other way around. You double tapped to zoom in a column, now you change from landscape to portrait, and you have to readjust the view in order to read the column. You do not need to do that on iOS or the N9. This is especially useful for desktop pages. As I explained the same content can be kept in view (e.g. you can be reading the same column, scrolled the same way down it). > > And showing the same content when you change orientation is still possible if you resize the viewport. It may require slightly more work by the browser, but even in the worst case if the layout changes significantly the browser could remember what block was currently centered (and how far through it you have scrolled), and make that block still be centered (and equivalently scrolled) after the orientation change. So all you really lose is the ability to so a perfectly smooth animation where you just rotate the page, which is a small price to pay in exchange for the page being much more usable after the orientation change - after all people spend much longer reading content than they do rotating their devices... > > It is much more complicated to do that for columns that you are zoomed into so that they fit the viewport width. Some columns might also be fixed sized (using images etc which should fix). It can probably be done, but I am afraid that there are so many corner cases which break. You can guarantee that the content they had centered is still centered. The things surrounding that content may well change (though in practice this is rarely a problem), but that should be "good enough". Hence having a decent but imperfect orientation change animation seems far preferable to sacrificing landscape mode, by making the text excessively large (note that when viewing desktop pages in Mobile Safari and N9 text is often too small in portrait mode, so the increased size in landscape can actually be a benefit; but if text had already been an easily legible size in portrait mode, it would be even larger in landscape mode). 700828 13 kenneth 2012-08-21 09:24:13 -0700 (In reply to comment #12) > (In reply to comment #11) > > But on the other hand, people who want to mimic native apps don't want whole-ui zooming as that is not something that people are used to in native apps. > > Sure - those people can just use user-scalable=no. But there are bunch of well-known web developers who want user-scalable=yes for its accessibility benefits yet dislike the Safari/N9 rotation behaviour: > > - http://adactio.com/journal/5088/ > - https://github.com/scottjehl/Device-Bugs/issues/2 > - http://www.456bereastreet.com/archive/201012/controlling_text_size_in_safari_for_ios_without_disabling_user_zoom/ > - https://github.com/h5bp/html5-boilerplate/issues/1099 > > Though according to https://twitter.com/wilto/status/212636063762628608 the Safari bug has been fixed in iOS 6, so it'll be possible to use a "width=device-width, initial-scale=1" viewport without the zoom glitching when you rotate from portrait to landscape. > > (In case you're wondering, I can't reproduce that exact bug on N9 if I try http://filamentgroup.com/examples/iosScaleBug/, but I do note that on http://jsbin.com/urowoh/44#device-width,scale=1 if you rotate from portrait to landscape you end up excessively zoomed in -- indeed, further than the maximum-scale allows -- which is fairly similar). Yes, it might seem as a bug, but I am pretty confident that it was designed this way. But I do agree that people want to have zooming allowed and still not having it auto adjust. That is a pretty valid use-case. It is pretty interesting that they changed this for the latest iOS. Do you have access to that? I am interested if they disable that for pages using the viewport meta tag or generally, or when using initial-scale? > > > It's not just web apps; most web pages I've seen override it too. > > > > I think many pages override it by mistake as they don't know what they are doing and the viewport meta tag is usually ignored in desktop browsers. > > While I agree that there's a lot of blind copy/pasting going on, I think the links above show that knowledgeable page authors also dislike the zooming; meanwhile I've yet to find anyone who actually likes it. I actually like it :-) I guess people who like it don't speak up as much as those two dislike it :-) Anyway, I like that I can read something in landscape, rotate and still read it without having to do additional zooming. I agree that this is most useful for desktop pages with columns. I am most interesting in how iOS "solved" this. Because it would be best to standardize this in the spec. > As I explained the same content can be kept in view (e.g. you can be reading the same column, scrolled the same way down it). But then you might still need to change the scale to fit the width into the smaller viewport width (going from landscape to portrait) > You can guarantee that the content they had centered is still centered. The things surrounding that content may well change (though in practice this is rarely a problem), but that should be "good enough". Maybe it is not a problem, and works well in practice. Are you doing something like this for Android? > Hence having a decent but imperfect orientation change animation seems far preferable to sacrificing landscape mode, by making the text excessively large (note that when viewing desktop pages in Mobile Safari and N9 text is often too small in portrait mode, so the increased size in landscape can actually be a benefit; but if text had already been an easily legible size in portrait mode, it would be even larger in landscape mode). Sure... 701835 14 johnme 2012-08-22 06:22:30 -0700 (In reply to comment #13) > I am most interesting in how iOS "solved" this. Before iOS 6, if you had a "width=device-width, initial-scale=1" viewport, then the viewport would resize in order to avoid scaling (hence by adding the inital-scale=1, device-width becomes larger in landscape, as in other browsers). However if you did just this, without an accompanying maximum-scale=1, then when rotating from portrait to landscape you would end up zoomed in (by 480/320 = 1.5x). Rotating from landscape to portrait was fine (as iOS doesn't let you zoom such that the page is narrower than the screen). Since iOS 6, if you have such a viewport and rotate from portrait to landscape, you remain at the initial-scale, rather than ending up arbitrarily zoomed in. A relayout will of course occur (as it did before too). > Because it would be best to standardize this in the spec. This whole area is in dire need of speccing. css-device-adapt is a great start, but there are lots of details, corner cases and knock-on effects which are unspecified and implemented differently across browsers (take window.outerWidth for example [1]) :| [1]: http://www.quirksmode.org/blog/archives/2012/03/windowouterwidt.html > > As I explained the same content can be kept in view (e.g. you can be reading the same column, scrolled the same way down it). > > But then you might still need to change the scale to fit the width into the smaller viewport width (going from landscape to portrait) Changing the zoom isn't so bad, since the user can always adjust the zoom later. > > You can guarantee that the content they had centered is still centered. The things surrounding that content may well change (though in practice this is rarely a problem), but that should be "good enough". > > Maybe it is not a problem, and works well in practice. Are you doing something like this for Android? We resize the viewports and adjust Font Boosting when you change orientation, but sadly we haven't yet gotten round to implementing the bit that keeps the same content onscreen. So it works fine for desktop sites without boosting like www.nytimes.com/?nytmobile=0, but for now you do indeed lose your scroll position on sites whose viewport widths change or when there is content above your scroll position which becomes more or less boosted. Of course it's fine if you change orientation before scrolling very far down the page, so it's not quite as bad as it sounds, but we do plan to improve this. 701880 15 kenneth 2012-08-22 07:20:07 -0700 (In reply to comment #14) > (In reply to comment #13) > > I am most interesting in how iOS "solved" this. > > Before iOS 6, if you had a "width=device-width, initial-scale=1" viewport, then the viewport would resize in order to avoid scaling (hence by adding the inital-scale=1, device-width becomes larger in landscape, as in other browsers). However if you did just this, without an accompanying maximum-scale=1, then when rotating from portrait to landscape you would end up zoomed in (by 480/320 = 1.5x). Rotating from landscape to portrait was fine (as iOS doesn't let you zoom such that the page is narrower than the screen). Aha, so that is not how it works on the N9 I believe. Because device-width becomes 320 (portrait) and as there is no maximum-scale it will scale it up by 1.8 (1.4 on iPhone) and not expand it to 480. That is how it works with the code in trunk when always using the width from portrait. > Since iOS 6, if you have such a viewport and rotate from portrait to landscape, you remain at the initial-scale, rather than ending up arbitrarily zoomed in. A relayout will of course occur (as it did before too). What if you move away from initial-scale, ie scale it yourself? Can you confirm that they just started using the landscape device-width in landscape? > This whole area is in dire need of speccing. css-device-adapt is a great start, but there are lots of details, corner cases and knock-on effects which are unspecified and implemented differently across browsers (take window.outerWidth for example [1]) :| > > [1]: http://www.quirksmode.org/blog/archives/2012/03/windowouterwidt.html Yes, I also filed a but at W3C for that or was it innerWidth. > We resize the viewports and adjust Font Boosting when you change orientation, but sadly we haven't yet gotten round to implementing the bit that keeps the same content onscreen. So it works fine for desktop sites without boosting like www.nytimes.com/?nytmobile=0, but for now you do indeed lose your scroll position on sites whose viewport widths change or when there is content above your scroll position which becomes more or less boosted. Of course it's fine if you change orientation before scrolling very far down the page, so it's not quite as bad as it sounds, but we do plan to improve this. OK that sounds good. 701888 16 159469 kenneth 2012-08-22 07:39:53 -0700 Comment on attachment 159469 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=159469&action=review > Source/WebCore/rendering/TextAutosizer.cpp:95 > +float TextAutosizer::multiplyFontSize(float specifiedSize, float multiplier) I don't know whether we can find a better name. computeFontSizeGivenBaseMultiplier? hmm I don't have any good ideas right now. > Source/WebCore/rendering/style/RenderStyle.cpp:1221 > float multiplier = textAutosizingMultiplier(); Maybe it is good to rename this as it is not the exact multiplication factor anymore 701891 17 kenneth 2012-08-22 07:44:13 -0700 computeActualFontSize? :) as suggested by Simon Hausmann. 702863 18 johnme 2012-08-23 04:37:40 -0700 (In reply to comment #15) > Aha, so that is not how it works on the N9 I believe. Because device-width becomes 320 (portrait) and as there is no maximum-scale it will scale it up by 1.8 (1.4 on iPhone) and not expand it to 480. That is how it works with the code in trunk when always using the width from portrait. With jsbin.com/urowoh/45#scale=1 (a simple "initial-scale=1" viewport) on the N9 when you rotate from portrait to landscape the device-width changes from 320 to 569 (press recompute to update the reading). So it seems like you do the same as Apple in that respect. > > Since iOS 6, if you have such a viewport and rotate from portrait to landscape, you remain at the initial-scale, rather than ending up arbitrarily zoomed in. A relayout will of course occur (as it did before too). > > What if you move away from initial-scale, ie scale it yourself? Can you confirm that they just started using the landscape device-width in landscape? If you're slightly zoomed in and rotate from portrait to landscape then you'll end up significantly zoomed in since you'll gain 1.5x zoom (relative to overview; arguably your zoom level is constant but overview zoom level changed) as before. So it seems like they've just special-cased the case where you were in overview zoom level (fully zoomed out), and keep you fully zoomed out after rotating. Conversely if you're somewhat zoomed in and rotate from landscape to portrait you'll lose 1.5x zoom (relative to overview; arguably your zoom level is constant but overview zoom level changed), so if you were only slightly zoomed in you'll end up in overview. (In reply to comment #16) > > Source/WebCore/rendering/TextAutosizer.cpp:95 > > +float TextAutosizer::multiplyFontSize(float specifiedSize, float multiplier) > > I don't know whether we can find a better name. computeFontSizeGivenBaseMultiplier? hmm I don't have any good ideas right now. > > computeActualFontSize? :) as suggested by Simon Hausmann. How about computeAutosizedFontSize? > > Source/WebCore/rendering/style/RenderStyle.cpp:1221 > > float multiplier = textAutosizingMultiplier(); > > Maybe it is good to rename this as it is not the exact multiplication factor anymore Hmm, I can't really think of a better name for it. It's role is essentially still to be a multiplication factor; there's just a slightly subtlety in how it gets applied. 702865 19 160127 johnme 2012-08-23 04:40:23 -0700 Created attachment 160127 Patch Renamed multiplyFontSize to computeAutosizedFontSize. 702872 20 160127 kenneth 2012-08-23 04:45:13 -0700 Comment on attachment 160127 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=160127&action=review > Source/WebCore/rendering/TextAutosizer.h:54 > + static float computeAutosizedFontSize(float specifiedSize, float multiplier); Ithought the name TextAutosizer::computeActualFontSize made sense as it is part of TextAutosizer, but this is ok 702873 21 kenneth 2012-08-23 04:49:31 -0700 (In reply to comment #18) > (In reply to comment #15) > > Aha, so that is not how it works on the N9 I believe. Because device-width becomes 320 (portrait) and as there is no maximum-scale it will scale it up by 1.8 (1.4 on iPhone) and not expand it to 480. That is how it works with the code in trunk when always using the width from portrait. > > With jsbin.com/urowoh/45#scale=1 (a simple "initial-scale=1" viewport) on the N9 when you rotate from portrait to landscape the device-width changes from 320 to 569 (press recompute to update the reading). So it seems like you do the same as Apple in that respect. Oh really? I wonder whether this changed in trunk or whether it was changed by the N9 browser maintenance team. Adding abinader maybe he knows. 702880 22 kenneth 2012-08-23 04:56:11 -0700 (In reply to comment #18) > (In reply to comment #15) > > Aha, so that is not how it works on the N9 I believe. Because device-width becomes 320 (portrait) and as there is no maximum-scale it will scale it up by 1.8 (1.4 on iPhone) and not expand it to 480. That is how it works with the code in trunk when always using the width from portrait. > > With jsbin.com/urowoh/45#scale=1 (a simple "initial-scale=1" viewport) on the N9 when you rotate from portrait to landscape the device-width changes from 320 to 569 (press recompute to update the reading). So it seems like you do the same as Apple in that respect. Nice test page! I though you were talking about initial-scale=1,width=device-width. I tried to test that on the test page but it auto adds maximum-scale=1 702892 23 bruno.abinader 2012-08-23 05:25:42 -0700 (In reply to comment #21) > (In reply to comment #18) > > (In reply to comment #15) > > > Aha, so that is not how it works on the N9 I believe. Because device-width becomes 320 (portrait) and as there is no maximum-scale it will scale it up by 1.8 (1.4 on iPhone) and not expand it to 480. That is how it works with the code in trunk when always using the width from portrait. > > > > With jsbin.com/urowoh/45#scale=1 (a simple "initial-scale=1" viewport) on the N9 when you rotate from portrait to landscape the device-width changes from 320 to 569 (press recompute to update the reading). So it seems like you do the same as Apple in that respect. > > Oh really? I wonder whether this changed in trunk or whether it was changed by the N9 browser maintenance team. Adding abinader maybe he knows. I'm afraid I can't help much, as I can only speak for the non-browser QtWebKit shared library on Nokia N9, as the browser had one library of its own. For the shared library, AFAIK there was no specific patch to address this issue. You can still find the public "mirror" of the N9 patchset [1]. In this case, I'd suggest you write a simple QML WebView that opens the jsbin.com page and check. [1] https://gitorious.org/~adriancjr/webkit/adriancjrs-qtwebkit-maemo6 702959 24 johnme 2012-08-23 07:18:30 -0700 (In reply to comment #22) > Nice test page! I though you were talking about initial-scale=1,width=device-width. I tried to test that on the test page but it auto adds maximum-scale=1 I added an option for that: http://jsbin.com/urowoh/48#device-width,initial=1 Do you think the patch is ready for commit-queue? 703070 25 160127 webkit.review.bot 2012-08-23 09:23:53 -0700 Comment on attachment 160127 Patch Clearing flags on attachment: 160127 Committed r126438: <http://trac.webkit.org/changeset/126438> 703071 26 webkit.review.bot 2012-08-23 09:23:58 -0700 All reviewed patches have been landed. Closing bug. 159145 2012-08-17 09:56:12 -0700 2012-08-20 10:29:41 -0700 Patch bug-94227-20120817175536.patch text/plain 9783 johnme U3VidmVyc2lvbiBSZXZpc2lvbjogMTI1NzA3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWMxZDJiNTAzNjBiYTQ4 ZDMwMGQwMjM0MGQ1OWJjN2JlNjIxM2ViZS4uMTI1N2I4NTQzMmMwZTRiNjM5NWVjMzc1MTFkZDYw YjRlNGQyOGY2ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDQ0IEBACiAyMDEyLTA4LTE3ICBKb2hu IE1lbGxvciAgPGpvaG5tZUBjaHJvbWl1bS5vcmc+CiAKKyAgICAgICAgVGV4dCBBdXRvc2l6aW5n OiBNdWx0aXBseSBsYXJnZSBmb250cyBsZXNzLCBhcyB0aGV5IGFyZSBhbHJlYWR5IG1vcmUgbGVn aWJsZS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk0 MjI3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmF0 aGVyIHRoYW4gdW5pZm9ybWx5IG11bHRpcGx5aW5nIGZvbnQgc2l6ZXMgYnkgdGhlIG11bHRpcGxp ZXIgKGRlcml2ZWQKKyAgICAgICAgZnJvbSB0aGUgd2lkdGggb2YgdGhlIGJsb2NrKSwgd2Ugc2hv dWxkIG11bHRpcGx5IGZvbnRzIHRoYXQgYXJlIGFscmVhZHkKKyAgICAgICAgbGFyZ2UgbGVzcywg c2luY2UgdGhleSBhcmUgYWxyZWFkeSBtb3JlIGxlZ2libGUgaGVuY2UgdGhlcmUgaXMgbGVzcyBu ZWVkCisgICAgICAgIGZvciB0aGVtIHRvIGdyb3cuCisKKyAgICAgICAgSG93ZXZlciBpdCBpcyBz dGlsbCBpbXBvcnRhbnQgdG8gbWFpbnRhaW4gZGlmZmVyZW50aWF0aW9uIGJldHdlZW4gdGV4dAor ICAgICAgICB0aGF0IHRoZSBhdXRob3Igc3BlY2lmaWVkIHRvIGJlIG9mIGRpZmZlcmVudCBzaXpl cy4KKworICAgICAgICBUaGlzIGFsZ29yaXRobSBtdWx0aXBsaWVzIHRleHQgYnkgdGhlIG11bHRp cGxpZXIgdXAgdW50aWwgYSBwcmVkZWZpbmVkCisgICAgICAgICJwbGVhc2FudCIgZm9udCBzaXpl OyBiZXlvbmQgdGhhdCB0aGUgY29tcHV0ZWRTaXplIGdvZXMgdXAgd2l0aAorICAgICAgICBzcGVj aWZpZWRTaXplIGJ1dCBhdCBhIGdyYWRpZW50IG9mIGxlc3MgdGhhbiAxIGluIG9yZGVyIHRvIGdy YWR1YWxseQorICAgICAgICBmYWRlIG91dCB0aGUgc2l6ZSBpbmNyZWFzZTsgZmluYWxseSBmb3Ig dmVyeSBsYXJnZSBzcGVjaWZpZWRTaXplcyB0aGUKKyAgICAgICAgY29tcHV0ZWRTaXplIHdpbGwg YmUgdGhlIHNhbWUgYXMgdGhlIHNwZWNpZmllZFNpemUuCisKKyAgICAgICAgRm9yIGZ1cnRoZXIg ZGV0YWlscywgaW5jbHVkaW5nIGEgZ3JhcGgsIHBsZWFzZSBzZWUgdGhlIGJ1ZyByZXBvcnQuCisK KyAgICAgICAgVGVzdDogZmFzdC90ZXh0LWF1dG9zaXppbmcvdmFyaW91cy1mb250LXNpemVzLmh0 bWwKKworICAgICAgICAqIHJlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlRleHRBdXRvc2l6ZXI6Om11bHRpcGx5Rm9udFNpemUpOgorCisgICAgICAgICAgICBJ bXBsZW1lbnRzIHRoZSBtdWx0aXBsaWNhdGlvbi4gU2VlIGNvbW1lbnQgZm9yIGRldGFpbHMuCisK KyAgICAgICAgKiByZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6UmVuZGVyU3R5bGU6OmxpbmVIZWlnaHQpOgorCisgICAgICAgICAgICBVc2UgbXVsdGlw bHlGb250U2l6ZSBpbnN0ZWFkIG9mIGRpcmVjdGx5IG11bHRpcGx5aW5nLgorCisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJTdHlsZTo6c2V0Rm9udFNpemUpOgorCisgICAgICAgICAgICBVc2UgbXVs dGlwbHlGb250U2l6ZSBpbnN0ZWFkIG9mIGRpcmVjdGx5IG11bHRpcGx5aW5nLgorCisyMDEyLTA4 LTE3ICBKb2huIE1lbGxvciAgPGpvaG5tZUBjaHJvbWl1bS5vcmc+CisKICAgICAgICAgVGV4dCBB dXRvc2l6aW5nOiBJbmNyZWFzZSBsaW5lIGhlaWdodCBpbiBwcm9wb3J0aW9uIHRvIGZvbnQgc2l6 ZS4KICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkxNjYw CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNw cCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcAppbmRleCA5NWIz ZTI5ZGNiODdjY2NiNjA1NzFkM2UxYTI4MzU1YTM2MWMyZDhkLi40NmUxYWIyZTI4NDZmNGY0MTRl M2QzMzZlYzNkNDMwOWNlZjg3ZmExIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvVGV4dEF1dG9zaXplci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRB dXRvc2l6ZXIuY3BwCkBAIC05Miw2ICs5MiwzNCBAQCB2b2lkIFRleHRBdXRvc2l6ZXI6OnNldE11 bHRpcGxpZXIoUmVuZGVyT2JqZWN0KiByZW5kZXJlciwgZmxvYXQgbXVsdGlwbGllcikKICAgICBy ZW5kZXJlci0+c2V0U3R5bGUobmV3U3R5bGUucmVsZWFzZSgpKTsKIH0KIAorZmxvYXQgVGV4dEF1 dG9zaXplcjo6bXVsdGlwbHlGb250U2l6ZShmbG9hdCBzcGVjaWZpZWRTaXplLCBmbG9hdCBtdWx0 aXBsaWVyKQoreworICAgIC8vIFNvbWV3aGF0IGFyYml0cmFyeSAicGxlYXNhbnQiIGZvbnQgc2l6 ZS4KKyAgICBjb25zdCBmbG9hdCBwbGVhc2FudFNpemUgPSAxNjsKKworICAgIC8vIE11bHRpcGx5 IGZvbnRzIHRoYXQgdGhlIHBhZ2UgYXV0aG9yIGhhcyBzcGVjaWZpZWQgdG8gYmUgbGFyZ2VyIHRo YW4KKyAgICAvLyBwbGVhc2FudFNpemUgYnkgbGVzcyBhbmQgbGVzcywgdW50aWwgaHVnZSBmb250 cyBhcmUgbm90IGluY3JlYXNlZCBhdCBhbGwuCisgICAgLy8gRm9yIHNwZWNpZmllZFNpemUgYmV0 d2VlbiAwIGFuZCBwbGVhc2FudFNpemUgd2UgZGlyZWN0bHkgYXBwbHkgdGhlCisgICAgLy8gbXVs dGlwbGllcjsgaGVuY2UgZm9yIHNwZWNpZmllZFNpemUgPT0gcGxlYXNhbnRTaXplLCBjb21wdXRl ZFNpemUgd2lsbCBiZQorICAgIC8vIG11bHRpcGxpZXIgKiBwbGVhc2FudFNpemUuIEZvciBncmVh dGVyIHNwZWNpZmllZFNpemVzIHdlIHdhbnQgdG8KKyAgICAvLyBncmFkdWFsbHkgZmFkZSBvdXQg dGhlIG11bHRpcGxpZXIsIHNvIGZvciBldmVyeSAxcHggaW5jcmVhc2UgaW4KKyAgICAvLyBzcGVj aWZpZWRTaXplIGJleW9uZCBwbGVhc2FudFNpemUgd2Ugd2lsbCBvbmx5IGluY3JlYXNlIGNvbXB1 dGVkU2l6ZQorICAgIC8vIGJ5IGdyYWRpZW50QWZ0ZXJQbGVhc2FudFNpemUgcHggdW50aWwgd2Ug bWVldCB0aGUKKyAgICAvLyBjb21wdXRlZFNpemUgPSBzcGVjaWZpZWRTaXplIGxpbmUsIGFmdGVy IHdoaWNoIHdlIHN0YXkgb24gdGhhdCBsaW5lIChzbworICAgIC8vIHRoZW4gZXZlcnkgMXB4IGlu Y3JlYXNlIGluIHNwZWNpZmllZFNpemUgaW5jcmVhc2VzIGNvbXB1dGVkU2l6ZSBieSAxcHgpLgor ICAgIGNvbnN0IGZsb2F0IGdyYWRpZW50QWZ0ZXJQbGVhc2FudFNpemUgPSAwLjU7CisKKyAgICBm bG9hdCBjb21wdXRlZFNpemU7CisgICAgaWYgKHNwZWNpZmllZFNpemUgPD0gcGxlYXNhbnRTaXpl KQorICAgICAgICBjb21wdXRlZFNpemUgPSBtdWx0aXBsaWVyICogc3BlY2lmaWVkU2l6ZTsKKyAg ICBlbHNlIHsKKyAgICAgICAgY29tcHV0ZWRTaXplID0gbXVsdGlwbGllciAqIHBsZWFzYW50U2l6 ZSArIGdyYWRpZW50QWZ0ZXJQbGVhc2FudFNpemUgKiAoc3BlY2lmaWVkU2l6ZSAtIHBsZWFzYW50 U2l6ZSk7CisgICAgICAgIGlmIChjb21wdXRlZFNpemUgPCBzcGVjaWZpZWRTaXplKQorICAgICAg ICAgICAgY29tcHV0ZWRTaXplID0gc3BlY2lmaWVkU2l6ZTsKKyAgICB9CisgICAgcmV0dXJuIGNv bXB1dGVkU2l6ZTsKK30KKwogYm9vbCBUZXh0QXV0b3NpemVyOjppc05vdEFuQXV0b3NpemluZ0Nv bnRhaW5lcihjb25zdCBSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogewogICAgIC8vICJBdXRvc2l6 aW5nIGNvbnRhaW5lcnMiIGFyZSB0aGUgc21hbGxlc3QgdW5pdCBmb3Igd2hpY2ggd2UgY2FuIGVu YWJsZS9kaXNhYmxlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1 dG9zaXplci5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaAppbmRl eCA0YjBiYzRhOTA1ZWMxM2Q5NzkyNTgyMWIzY2QxMjRhZmQxMjk4NTEyLi42NmU1Mzc4NDUxZjQ5 NWQ1NDVmNGFiOWM0MmRmMmQ5Y2JmYTBmMjY5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9U ZXh0QXV0b3NpemVyLmgKQEAgLTUxLDYgKzUxLDggQEAgcHVibGljOgogCiAgICAgYm9vbCBwcm9j ZXNzU3VidHJlZShSZW5kZXJPYmplY3QqIGxheW91dFJvb3QpOwogCisgICAgc3RhdGljIGZsb2F0 IG11bHRpcGx5Rm9udFNpemUoZmxvYXQgc3BlY2lmaWVkU2l6ZSwgZmxvYXQgbXVsdGlwbGllcik7 CisKIHByaXZhdGU6CiAgICAgZXhwbGljaXQgVGV4dEF1dG9zaXplcihEb2N1bWVudCopOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuY3Bw IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0eWxlLmNwcAppbmRleCA1 YjRjM2I5OTY3MDkyYmMzYWM4MDQ1ZTcwNjRhOWQzMDNjNDJiYjY5Li4yMTgwNTM4OWYwOTgxOTdh NDQ3ODZiZmI1NTQyOGQ1MTJmYTQwYjM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9zdHlsZS9SZW5kZXJTdHlsZS5jcHAKQEAgLTQxLDYgKzQxLDEwIEBACiAjaW5jbHVkZSA8d3Rm L1N0ZExpYkV4dHJhcy5oPgogI2luY2x1ZGUgPGFsZ29yaXRobT4KIAorI2lmIEVOQUJMRShURVhU X0FVVE9TSVpJTkcpCisjaW5jbHVkZSAiVGV4dEF1dG9zaXplci5oIgorI2VuZGlmCisKIHVzaW5n IG5hbWVzcGFjZSBzdGQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTEyMTYsNyArMTIyMCw3 IEBAIExlbmd0aCBSZW5kZXJTdHlsZTo6bGluZUhlaWdodCgpIGNvbnN0CiAgICAgLy8gdG9vLCB0 aG91Z2ggdGhpcyBpbnZvbHZlcyBtZXNzaWx5IHBva2luZyBpbnRvIENhbGNFeHByZXNzaW9uTGVu Z3RoLgogICAgIGZsb2F0IG11bHRpcGxpZXIgPSB0ZXh0QXV0b3NpemluZ011bHRpcGxpZXIoKTsK ICAgICBpZiAobXVsdGlwbGllciA+IDEgJiYgbGguaXNGaXhlZCgpKQotICAgICAgICByZXR1cm4g TGVuZ3RoKGxoLnZhbHVlKCkgKiBtdWx0aXBsaWVyLCBGaXhlZCk7CisgICAgICAgIHJldHVybiBM ZW5ndGgoVGV4dEF1dG9zaXplcjo6bXVsdGlwbHlGb250U2l6ZShsaC52YWx1ZSgpLCBtdWx0aXBs aWVyKSwgRml4ZWQpOwogI2VuZGlmCiAgICAgcmV0dXJuIGxoOwogfQpAQCAtMTI1NSw4ICsxMjU5 LDcgQEAgdm9pZCBSZW5kZXJTdHlsZTo6c2V0Rm9udFNpemUoZmxvYXQgc2l6ZSkKICNpZiBFTkFC TEUoVEVYVF9BVVRPU0laSU5HKQogICAgIGZsb2F0IG11bHRpcGxpZXIgPSB0ZXh0QXV0b3Npemlu Z011bHRpcGxpZXIoKTsKICAgICBpZiAobXVsdGlwbGllciA+IDEpIHsKLSAgICAgICAgLy8gRklY TUU6IExhcmdlIGZvbnQgc2l6ZXMgbmVlZG4ndCBiZSBtdWx0aXBsaWVkIGFzIG11Y2ggc2luY2Ug dGhleSBhcmUgYWxyZWFkeSBtb3JlIGxlZ2libGUuCi0gICAgICAgIGRlc2Muc2V0Q29tcHV0ZWRT aXplKHNpemUgKiBtdWx0aXBsaWVyKTsKKyAgICAgICAgZGVzYy5zZXRDb21wdXRlZFNpemUoVGV4 dEF1dG9zaXplcjo6bXVsdGlwbHlGb250U2l6ZShzaXplLCBtdWx0aXBsaWVyKSk7CiAgICAgfQog I2VuZGlmCiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3Rz L0NoYW5nZUxvZwppbmRleCBhYzE5Zjg4ZDViMjNlYzAwODc0YzQxZDJlMWYxNzUzOWFhNjk3M2Nm Li5mZjdiNTI0ODBiMTc0NzkyYjEyZTBlYWI1NDRjMWIyNzQyM2ZmN2U3IDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDUg KzEsMTcgQEAKIDIwMTItMDgtMTcgIEpvaG4gTWVsbG9yICA8am9obm1lQGNocm9taXVtLm9yZz4K IAorICAgICAgICBUZXh0IEF1dG9zaXppbmc6IE11bHRpcGx5IGxhcmdlIGZvbnRzIGxlc3MsIGFz IHRoZXkgYXJlIGFscmVhZHkgbW9yZSBsZWdpYmxlLgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTQyMjcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCB0ZXN0IGRlbW9uc3RyYXRpbmcgaG93IHZhcmlv dXMgZm9udCBzaXplcyBhcmUgYWZmZWN0ZWQuCisKKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3Np emluZy92YXJpb3VzLWZvbnQtc2l6ZXMtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICog ZmFzdC90ZXh0LWF1dG9zaXppbmcvdmFyaW91cy1mb250LXNpemVzLmh0bWw6IEFkZGVkLgorCisy MDEyLTA4LTE3ICBKb2huIE1lbGxvciAgPGpvaG5tZUBjaHJvbWl1bS5vcmc+CisKICAgICAgICAg VGV4dCBBdXRvc2l6aW5nOiBJbmNyZWFzZSBsaW5lIGhlaWdodCBpbiBwcm9wb3J0aW9uIHRvIGZv bnQgc2l6ZS4KICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTkxNjYwCiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL3Zh cmlvdXMtZm9udC1zaXplcy1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1 dG9zaXppbmcvdmFyaW91cy1mb250LXNpemVzLWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODcy MzYxZTcyMTZhMjAwNGRiMzM3NmJiOGVlMDhkOWM5Zjg3YjMxYgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL3ZhcmlvdXMtZm9udC1zaXplcy1leHBl Y3RlZC5odG1sCkBAIC0wLDAgKzEsMjcgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVh ZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGUg dHlwZT0idGV4dC9jc3MiPgorYm9keSB7IHdpZHRoOiA4MDBweDsgbWFyZ2luOiAwOyB9Cis8L3N0 eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyMHB4Ij4K KyAgICBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcg ZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9y ZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlzIG5vc3RydWQgZXhl cmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1aXAgZXggZWEgY29tbW9kbyBj b25zZXF1YXQuCis8L2Rpdj4KKzxkaXYgc3R5bGU9ImZvbnQtc2l6ZTogNDBweCI+CisgICAgTG9y ZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNl ZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEg YWxpcXVhLgorPC9kaXY+Cis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDQ4cHgiPgorICAgIExvcmVt IGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQg ZG8gZWl1c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hLgor PC9kaXY+Cis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDU2cHgiPgorICAgIExvcmVtIGlwc3VtIGRv bG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21v ZCB0ZW1wb3IgaW5jaWRpZHVudCB1dC4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy92YXJpb3VzLWZvbnQtc2l6 ZXMuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL3ZhcmlvdXMtZm9udC1z aXplcy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLmI4NDY5Mjc4Njk3Y2RjMTJjMTM2YmY0Zjc0ODRkZGIyZWRh Y2I5NTEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3Npemlu Zy92YXJpb3VzLWZvbnQtc2l6ZXMuaHRtbApAQCAtMCwwICsxLDM2IEBACis8IURPQ1RZUEUgaHRt bD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0 aD04MDAiPgorPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KK2JvZHkgeyB3aWR0aDogODAwcHg7IG1h cmdpbjogMDsgfQorPC9zdHlsZT4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgor aWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNl dFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRp bmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30gZWxz ZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29uc29sZS53YXJu KCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVpbmcg dHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUgVGV4 dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBweCBk ZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19GT1JD RV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hlYWQ+ Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiA4cHgiPgorICAgIExvcmVtIGlwc3Vt IGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1 c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4g VXQgZW5pbSBhZCBtaW5pbSB2ZW5pYW0sIHF1aXMgbm9zdHJ1ZCBleGVyY2l0YXRpb24gdWxsYW1j byBsYWJvcmlzIG5pc2kgdXQgYWxpcXVpcCBleCBlYSBjb21tb2RvIGNvbnNlcXVhdC4KKzwvZGl2 PgorPGRpdiBzdHlsZT0iZm9udC1zaXplOiAxNnB4Ij4KKyAgICBMb3JlbSBpcHN1bSBkb2xvciBz aXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVt cG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4K KzxkaXYgc3R5bGU9ImZvbnQtc2l6ZTogMzJweCI+CisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0 IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBv ciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEuCis8L2Rpdj4KKzxkaXYgc3R5 bGU9ImZvbnQtc2l6ZTogNDhweCI+CisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNv bnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlk dW50IHV0LgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4K 159469 2012-08-20 10:29:47 -0700 2012-08-23 04:40:18 -0700 Patch bug-94227-20120820182907.patch text/plain 9663 johnme U3VidmVyc2lvbiBSZXZpc2lvbjogMTI1OTY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTI1ZDJjYzVlZTEzZTRj NTI2NmUyMzNkMzVhOTQ5ODA4NTcyOWRhOS4uNjhkNDFkNDc0NTI1MTBmMGY4NzE0OGY5M2UwMzIw ZjkwYzk5YWFlNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQyIEBACisyMDEyLTA4LTE3ICBKb2hu IE1lbGxvciAgPGpvaG5tZUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgVGV4dCBBdXRvc2l6aW5n OiBNdWx0aXBseSBsYXJnZSBmb250cyBsZXNzLCBhcyB0aGV5IGFyZSBhbHJlYWR5IG1vcmUgbGVn aWJsZS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk0 MjI3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmF0 aGVyIHRoYW4gdW5pZm9ybWx5IG11bHRpcGx5aW5nIGZvbnQgc2l6ZXMgYnkgdGhlIG11bHRpcGxp ZXIgKGRlcml2ZWQKKyAgICAgICAgZnJvbSB0aGUgd2lkdGggb2YgdGhlIGJsb2NrKSwgd2Ugc2hv dWxkIG11bHRpcGx5IGZvbnRzIHRoYXQgYXJlIGFscmVhZHkKKyAgICAgICAgbGFyZ2UgbGVzcywg c2luY2UgdGhleSBhcmUgYWxyZWFkeSBtb3JlIGxlZ2libGUgaGVuY2UgdGhlcmUgaXMgbGVzcyBu ZWVkCisgICAgICAgIGZvciB0aGVtIHRvIGdyb3cuCisKKyAgICAgICAgSG93ZXZlciBpdCBpcyBz dGlsbCBpbXBvcnRhbnQgdG8gbWFpbnRhaW4gZGlmZmVyZW50aWF0aW9uIGJldHdlZW4gdGV4dAor ICAgICAgICB0aGF0IHRoZSBhdXRob3Igc3BlY2lmaWVkIHRvIGJlIG9mIGRpZmZlcmVudCBzaXpl cy4KKworICAgICAgICBUaGlzIGFsZ29yaXRobSBtdWx0aXBsaWVzIHRleHQgYnkgdGhlIG11bHRp cGxpZXIgdXAgdW50aWwgYSBwcmVkZWZpbmVkCisgICAgICAgICJwbGVhc2FudCIgZm9udCBzaXpl OyBiZXlvbmQgdGhhdCB0aGUgY29tcHV0ZWRTaXplIGdvZXMgdXAgd2l0aAorICAgICAgICBzcGVj aWZpZWRTaXplIGJ1dCBhdCBhIGdyYWRpZW50IG9mIGxlc3MgdGhhbiAxIGluIG9yZGVyIHRvIGdy YWR1YWxseQorICAgICAgICBmYWRlIG91dCB0aGUgc2l6ZSBpbmNyZWFzZTsgZmluYWxseSBmb3Ig dmVyeSBsYXJnZSBzcGVjaWZpZWRTaXplcyB0aGUKKyAgICAgICAgY29tcHV0ZWRTaXplIHdpbGwg YmUgdGhlIHNhbWUgYXMgdGhlIHNwZWNpZmllZFNpemUuCisKKyAgICAgICAgRm9yIGZ1cnRoZXIg ZGV0YWlscywgaW5jbHVkaW5nIGEgZ3JhcGgsIHBsZWFzZSBzZWUgdGhlIGJ1ZyByZXBvcnQuCisK KyAgICAgICAgVGVzdDogZmFzdC90ZXh0LWF1dG9zaXppbmcvdmFyaW91cy1mb250LXNpemVzLmh0 bWwKKworICAgICAgICAqIHJlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlRleHRBdXRvc2l6ZXI6Om11bHRpcGx5Rm9udFNpemUpOgorCisgICAgICAgICAgICBJ bXBsZW1lbnRzIHRoZSBtdWx0aXBsaWNhdGlvbi4gU2VlIGNvbW1lbnQgZm9yIGRldGFpbHMuCisK KyAgICAgICAgKiByZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6UmVuZGVyU3R5bGU6OmxpbmVIZWlnaHQpOgorCisgICAgICAgICAgICBVc2UgbXVsdGlw bHlGb250U2l6ZSBpbnN0ZWFkIG9mIGRpcmVjdGx5IG11bHRpcGx5aW5nLgorCisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJTdHlsZTo6c2V0Rm9udFNpemUpOgorCisgICAgICAgICAgICBVc2UgbXVs dGlwbHlGb250U2l6ZSBpbnN0ZWFkIG9mIGRpcmVjdGx5IG11bHRpcGx5aW5nLgorCiAyMDEyLTA4 LTE4ICBQYXZlbCBGZWxkbWFuICA8cGZlbGRtYW5AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFdl YiBJbnNwZWN0b3I6IG1ha2UgcHJvZmlsZXMgcGFuZWwgYSBsYXppbHkgbG9hZGVkIG1vZHVsZS4K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcAppbmRleCA5NWIzZTI5 ZGNiODdjY2NiNjA1NzFkM2UxYTI4MzU1YTM2MWMyZDhkLi40NmUxYWIyZTI4NDZmNGY0MTRlM2Qz MzZlYzNkNDMwOWNlZjg3ZmExIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv VGV4dEF1dG9zaXplci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRv c2l6ZXIuY3BwCkBAIC05Miw2ICs5MiwzNCBAQCB2b2lkIFRleHRBdXRvc2l6ZXI6OnNldE11bHRp cGxpZXIoUmVuZGVyT2JqZWN0KiByZW5kZXJlciwgZmxvYXQgbXVsdGlwbGllcikKICAgICByZW5k ZXJlci0+c2V0U3R5bGUobmV3U3R5bGUucmVsZWFzZSgpKTsKIH0KIAorZmxvYXQgVGV4dEF1dG9z aXplcjo6bXVsdGlwbHlGb250U2l6ZShmbG9hdCBzcGVjaWZpZWRTaXplLCBmbG9hdCBtdWx0aXBs aWVyKQoreworICAgIC8vIFNvbWV3aGF0IGFyYml0cmFyeSAicGxlYXNhbnQiIGZvbnQgc2l6ZS4K KyAgICBjb25zdCBmbG9hdCBwbGVhc2FudFNpemUgPSAxNjsKKworICAgIC8vIE11bHRpcGx5IGZv bnRzIHRoYXQgdGhlIHBhZ2UgYXV0aG9yIGhhcyBzcGVjaWZpZWQgdG8gYmUgbGFyZ2VyIHRoYW4K KyAgICAvLyBwbGVhc2FudFNpemUgYnkgbGVzcyBhbmQgbGVzcywgdW50aWwgaHVnZSBmb250cyBh cmUgbm90IGluY3JlYXNlZCBhdCBhbGwuCisgICAgLy8gRm9yIHNwZWNpZmllZFNpemUgYmV0d2Vl biAwIGFuZCBwbGVhc2FudFNpemUgd2UgZGlyZWN0bHkgYXBwbHkgdGhlCisgICAgLy8gbXVsdGlw bGllcjsgaGVuY2UgZm9yIHNwZWNpZmllZFNpemUgPT0gcGxlYXNhbnRTaXplLCBjb21wdXRlZFNp emUgd2lsbCBiZQorICAgIC8vIG11bHRpcGxpZXIgKiBwbGVhc2FudFNpemUuIEZvciBncmVhdGVy IHNwZWNpZmllZFNpemVzIHdlIHdhbnQgdG8KKyAgICAvLyBncmFkdWFsbHkgZmFkZSBvdXQgdGhl IG11bHRpcGxpZXIsIHNvIGZvciBldmVyeSAxcHggaW5jcmVhc2UgaW4KKyAgICAvLyBzcGVjaWZp ZWRTaXplIGJleW9uZCBwbGVhc2FudFNpemUgd2Ugd2lsbCBvbmx5IGluY3JlYXNlIGNvbXB1dGVk U2l6ZQorICAgIC8vIGJ5IGdyYWRpZW50QWZ0ZXJQbGVhc2FudFNpemUgcHggdW50aWwgd2UgbWVl dCB0aGUKKyAgICAvLyBjb21wdXRlZFNpemUgPSBzcGVjaWZpZWRTaXplIGxpbmUsIGFmdGVyIHdo aWNoIHdlIHN0YXkgb24gdGhhdCBsaW5lIChzbworICAgIC8vIHRoZW4gZXZlcnkgMXB4IGluY3Jl YXNlIGluIHNwZWNpZmllZFNpemUgaW5jcmVhc2VzIGNvbXB1dGVkU2l6ZSBieSAxcHgpLgorICAg IGNvbnN0IGZsb2F0IGdyYWRpZW50QWZ0ZXJQbGVhc2FudFNpemUgPSAwLjU7CisKKyAgICBmbG9h dCBjb21wdXRlZFNpemU7CisgICAgaWYgKHNwZWNpZmllZFNpemUgPD0gcGxlYXNhbnRTaXplKQor ICAgICAgICBjb21wdXRlZFNpemUgPSBtdWx0aXBsaWVyICogc3BlY2lmaWVkU2l6ZTsKKyAgICBl bHNlIHsKKyAgICAgICAgY29tcHV0ZWRTaXplID0gbXVsdGlwbGllciAqIHBsZWFzYW50U2l6ZSAr IGdyYWRpZW50QWZ0ZXJQbGVhc2FudFNpemUgKiAoc3BlY2lmaWVkU2l6ZSAtIHBsZWFzYW50U2l6 ZSk7CisgICAgICAgIGlmIChjb21wdXRlZFNpemUgPCBzcGVjaWZpZWRTaXplKQorICAgICAgICAg ICAgY29tcHV0ZWRTaXplID0gc3BlY2lmaWVkU2l6ZTsKKyAgICB9CisgICAgcmV0dXJuIGNvbXB1 dGVkU2l6ZTsKK30KKwogYm9vbCBUZXh0QXV0b3NpemVyOjppc05vdEFuQXV0b3NpemluZ0NvbnRh aW5lcihjb25zdCBSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogewogICAgIC8vICJBdXRvc2l6aW5n IGNvbnRhaW5lcnMiIGFyZSB0aGUgc21hbGxlc3QgdW5pdCBmb3Igd2hpY2ggd2UgY2FuIGVuYWJs ZS9kaXNhYmxlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9z aXplci5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaAppbmRleCA0 YjBiYzRhOTA1ZWMxM2Q5NzkyNTgyMWIzY2QxMjRhZmQxMjk4NTEyLi42NmU1Mzc4NDUxZjQ5NWQ1 NDVmNGFiOWM0MmRmMmQ5Y2JmYTBmMjY5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvVGV4dEF1dG9zaXplci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0 QXV0b3NpemVyLmgKQEAgLTUxLDYgKzUxLDggQEAgcHVibGljOgogCiAgICAgYm9vbCBwcm9jZXNz U3VidHJlZShSZW5kZXJPYmplY3QqIGxheW91dFJvb3QpOwogCisgICAgc3RhdGljIGZsb2F0IG11 bHRpcGx5Rm9udFNpemUoZmxvYXQgc3BlY2lmaWVkU2l6ZSwgZmxvYXQgbXVsdGlwbGllcik7CisK IHByaXZhdGU6CiAgICAgZXhwbGljaXQgVGV4dEF1dG9zaXplcihEb2N1bWVudCopOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuY3BwIGIv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0eWxlLmNwcAppbmRleCA1YjRj M2I5OTY3MDkyYmMzYWM4MDQ1ZTcwNjRhOWQzMDNjNDJiYjY5Li4yMTgwNTM4OWYwOTgxOTdhNDQ3 ODZiZmI1NTQyOGQ1MTJmYTQwYjM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvc3R5bGUvUmVuZGVyU3R5bGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9z dHlsZS9SZW5kZXJTdHlsZS5jcHAKQEAgLTQxLDYgKzQxLDEwIEBACiAjaW5jbHVkZSA8d3RmL1N0 ZExpYkV4dHJhcy5oPgogI2luY2x1ZGUgPGFsZ29yaXRobT4KIAorI2lmIEVOQUJMRShURVhUX0FV VE9TSVpJTkcpCisjaW5jbHVkZSAiVGV4dEF1dG9zaXplci5oIgorI2VuZGlmCisKIHVzaW5nIG5h bWVzcGFjZSBzdGQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTEyMTYsNyArMTIyMCw3IEBA IExlbmd0aCBSZW5kZXJTdHlsZTo6bGluZUhlaWdodCgpIGNvbnN0CiAgICAgLy8gdG9vLCB0aG91 Z2ggdGhpcyBpbnZvbHZlcyBtZXNzaWx5IHBva2luZyBpbnRvIENhbGNFeHByZXNzaW9uTGVuZ3Ro LgogICAgIGZsb2F0IG11bHRpcGxpZXIgPSB0ZXh0QXV0b3NpemluZ011bHRpcGxpZXIoKTsKICAg ICBpZiAobXVsdGlwbGllciA+IDEgJiYgbGguaXNGaXhlZCgpKQotICAgICAgICByZXR1cm4gTGVu Z3RoKGxoLnZhbHVlKCkgKiBtdWx0aXBsaWVyLCBGaXhlZCk7CisgICAgICAgIHJldHVybiBMZW5n dGgoVGV4dEF1dG9zaXplcjo6bXVsdGlwbHlGb250U2l6ZShsaC52YWx1ZSgpLCBtdWx0aXBsaWVy KSwgRml4ZWQpOwogI2VuZGlmCiAgICAgcmV0dXJuIGxoOwogfQpAQCAtMTI1NSw4ICsxMjU5LDcg QEAgdm9pZCBSZW5kZXJTdHlsZTo6c2V0Rm9udFNpemUoZmxvYXQgc2l6ZSkKICNpZiBFTkFCTEUo VEVYVF9BVVRPU0laSU5HKQogICAgIGZsb2F0IG11bHRpcGxpZXIgPSB0ZXh0QXV0b3NpemluZ011 bHRpcGxpZXIoKTsKICAgICBpZiAobXVsdGlwbGllciA+IDEpIHsKLSAgICAgICAgLy8gRklYTUU6 IExhcmdlIGZvbnQgc2l6ZXMgbmVlZG4ndCBiZSBtdWx0aXBsaWVkIGFzIG11Y2ggc2luY2UgdGhl eSBhcmUgYWxyZWFkeSBtb3JlIGxlZ2libGUuCi0gICAgICAgIGRlc2Muc2V0Q29tcHV0ZWRTaXpl KHNpemUgKiBtdWx0aXBsaWVyKTsKKyAgICAgICAgZGVzYy5zZXRDb21wdXRlZFNpemUoVGV4dEF1 dG9zaXplcjo6bXVsdGlwbHlGb250U2l6ZShzaXplLCBtdWx0aXBsaWVyKSk7CiAgICAgfQogI2Vu ZGlmCiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0No YW5nZUxvZwppbmRleCA2N2U3ODI3NDVmNTM3NGRmMzFlYTExYWQwOTdmNzQ4YzUxMDM1OGVlLi5i NDZjNjI0ZDc4MWE0Y2Y5MzFhOTczYTAwNzg2NzEyYzQ0NjY1MTA3IDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTUgQEAKKzIwMTItMDgtMTcgIEpvaG4gTWVsbG9yICA8am9obm1lQGNocm9taXVtLm9yZz4KKwor ICAgICAgICBUZXh0IEF1dG9zaXppbmc6IE11bHRpcGx5IGxhcmdlIGZvbnRzIGxlc3MsIGFzIHRo ZXkgYXJlIGFscmVhZHkgbW9yZSBsZWdpYmxlLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTQyMjcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGRlZCB0ZXN0IGRlbW9uc3RyYXRpbmcgaG93IHZhcmlvdXMg Zm9udCBzaXplcyBhcmUgYWZmZWN0ZWQuCisKKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3Npemlu Zy92YXJpb3VzLWZvbnQtc2l6ZXMtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFz dC90ZXh0LWF1dG9zaXppbmcvdmFyaW91cy1mb250LXNpemVzLmh0bWw6IEFkZGVkLgorCiAyMDEy LTA4LTE4ICBQYXZlbCBGZWxkbWFuICA8cGZlbGRtYW5AY2hyb21pdW0ub3JnPgogCiAgICAgICAg IFdlYiBJbnNwZWN0b3I6IG1ha2UgcHJvZmlsZXMgcGFuZWwgYSBsYXppbHkgbG9hZGVkIG1vZHVs ZS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL3ZhcmlvdXMt Zm9udC1zaXplcy1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXpp bmcvdmFyaW91cy1mb250LXNpemVzLWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODcyMzYxZTcy MTZhMjAwNGRiMzM3NmJiOGVlMDhkOWM5Zjg3YjMxYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL3ZhcmlvdXMtZm9udC1zaXplcy1leHBlY3RlZC5o dG1sCkBAIC0wLDAgKzEsMjcgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKwor PG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGUgdHlwZT0i dGV4dC9jc3MiPgorYm9keSB7IHdpZHRoOiA4MDBweDsgbWFyZ2luOiAwOyB9Cis8L3N0eWxlPgor Cis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyMHB4Ij4KKyAgICBM b3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwg c2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWdu YSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlzIG5vc3RydWQgZXhlcmNpdGF0 aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1aXAgZXggZWEgY29tbW9kbyBjb25zZXF1 YXQuCis8L2Rpdj4KKzxkaXYgc3R5bGU9ImZvbnQtc2l6ZTogNDBweCI+CisgICAgTG9yZW0gaXBz dW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBl aXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVh LgorPC9kaXY+Cis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDQ4cHgiPgorICAgIExvcmVtIGlwc3Vt IGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1 c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hLgorPC9kaXY+ Cis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDU2cHgiPgorICAgIExvcmVtIGlwc3VtIGRvbG9yIHNp dCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1w b3IgaW5jaWRpZHVudCB1dC4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy92YXJpb3VzLWZvbnQtc2l6ZXMuaHRt bCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL3ZhcmlvdXMtZm9udC1zaXplcy5o dG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLmI4NDY5Mjc4Njk3Y2RjMTJjMTM2YmY0Zjc0ODRkZGIyZWRhY2I5NTEK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy92YXJp b3VzLWZvbnQtc2l6ZXMuaHRtbApAQCAtMCwwICsxLDM2IEBACis8IURPQ1RZUEUgaHRtbD4KKzxo dG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAi PgorPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KK2JvZHkgeyB3aWR0aDogODAwcHg7IG1hcmdpbjog MDsgfQorPC9zdHlsZT4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgoraWYgKHdp bmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRB dXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNl dFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30gZWxzZSBpZiAo d2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29uc29sZS53YXJuKCJUaGlz IHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVpbmcgdHJ1ZSwg c28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUgVGV4dCBBdXRv c2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBweCBkZXZpY2Ut d2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19GT1JDRV9URVhU X0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hlYWQ+Cis8Ym9k eT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiA4cHgiPgorICAgIExvcmVtIGlwc3VtIGRvbG9y IHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0 ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4gVXQgZW5p bSBhZCBtaW5pbSB2ZW5pYW0sIHF1aXMgbm9zdHJ1ZCBleGVyY2l0YXRpb24gdWxsYW1jbyBsYWJv cmlzIG5pc2kgdXQgYWxpcXVpcCBleCBlYSBjb21tb2RvIGNvbnNlcXVhdC4KKzwvZGl2PgorPGRp diBzdHlsZT0iZm9udC1zaXplOiAxNnB4Ij4KKyAgICBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1l dCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGlu Y2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXYg c3R5bGU9ImZvbnQtc2l6ZTogMzJweCI+CisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQs IGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNp ZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEuCis8L2Rpdj4KKzxkaXYgc3R5bGU9ImZv bnQtc2l6ZTogNDhweCI+CisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3Rl dHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0 LgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4K 160127 2012-08-23 04:40:23 -0700 2012-08-23 09:23:53 -0700 Patch bug-94227-20120823124020.patch text/plain 9726 johnme U3VidmVyc2lvbiBSZXZpc2lvbjogMTI1OTY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTI1ZDJjYzVlZTEzZTRj NTI2NmUyMzNkMzVhOTQ5ODA4NTcyOWRhOS4uMDkxMjU0ODkzZjc5NWFhODIzNDMxZDMzZTc1MDNl Njk4YzZjODBhMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQyIEBACisyMDEyLTA4LTIzICBKb2hu IE1lbGxvciAgPGpvaG5tZUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgVGV4dCBBdXRvc2l6aW5n OiBNdWx0aXBseSBsYXJnZSBmb250cyBsZXNzLCBhcyB0aGV5IGFyZSBhbHJlYWR5IG1vcmUgbGVn aWJsZS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk0 MjI3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmF0 aGVyIHRoYW4gdW5pZm9ybWx5IG11bHRpcGx5aW5nIGZvbnQgc2l6ZXMgYnkgdGhlIG11bHRpcGxp ZXIgKGRlcml2ZWQKKyAgICAgICAgZnJvbSB0aGUgd2lkdGggb2YgdGhlIGJsb2NrKSwgd2Ugc2hv dWxkIG11bHRpcGx5IGZvbnRzIHRoYXQgYXJlIGFscmVhZHkKKyAgICAgICAgbGFyZ2UgbGVzcywg c2luY2UgdGhleSBhcmUgYWxyZWFkeSBtb3JlIGxlZ2libGUgaGVuY2UgdGhlcmUgaXMgbGVzcyBu ZWVkCisgICAgICAgIGZvciB0aGVtIHRvIGdyb3cuCisKKyAgICAgICAgSG93ZXZlciBpdCBpcyBz dGlsbCBpbXBvcnRhbnQgdG8gbWFpbnRhaW4gZGlmZmVyZW50aWF0aW9uIGJldHdlZW4gdGV4dAor ICAgICAgICB0aGF0IHRoZSBhdXRob3Igc3BlY2lmaWVkIHRvIGJlIG9mIGRpZmZlcmVudCBzaXpl cy4KKworICAgICAgICBUaGlzIGFsZ29yaXRobSBtdWx0aXBsaWVzIHRleHQgYnkgdGhlIG11bHRp cGxpZXIgdXAgdW50aWwgYSBwcmVkZWZpbmVkCisgICAgICAgICJwbGVhc2FudCIgZm9udCBzaXpl OyBiZXlvbmQgdGhhdCB0aGUgY29tcHV0ZWRTaXplIGdvZXMgdXAgd2l0aAorICAgICAgICBzcGVj aWZpZWRTaXplIGJ1dCBhdCBhIGdyYWRpZW50IG9mIGxlc3MgdGhhbiAxIGluIG9yZGVyIHRvIGdy YWR1YWxseQorICAgICAgICBmYWRlIG91dCB0aGUgc2l6ZSBpbmNyZWFzZTsgZmluYWxseSBmb3Ig dmVyeSBsYXJnZSBzcGVjaWZpZWRTaXplcyB0aGUKKyAgICAgICAgY29tcHV0ZWRTaXplIHdpbGwg YmUgdGhlIHNhbWUgYXMgdGhlIHNwZWNpZmllZFNpemUuCisKKyAgICAgICAgRm9yIGZ1cnRoZXIg ZGV0YWlscywgaW5jbHVkaW5nIGEgZ3JhcGgsIHBsZWFzZSBzZWUgdGhlIGJ1ZyByZXBvcnQuCisK KyAgICAgICAgVGVzdDogZmFzdC90ZXh0LWF1dG9zaXppbmcvdmFyaW91cy1mb250LXNpemVzLmh0 bWwKKworICAgICAgICAqIHJlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlRleHRBdXRvc2l6ZXI6OmNvbXB1dGVBdXRvc2l6ZWRGb250U2l6ZSk6CisKKyAgICAg ICAgICAgIEltcGxlbWVudHMgdGhlIGN1c3RvbSBtdWx0aXBsaWNhdGlvbi4gU2VlIGNvbW1lbnQg Zm9yIGRldGFpbHMuCisKKyAgICAgICAgKiByZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyU3R5bGU6OmxpbmVIZWlnaHQpOgorCisgICAgICAg ICAgICBVc2UgY29tcHV0ZUF1dG9zaXplZEZvbnRTaXplIGluc3RlYWQgb2YgZGlyZWN0bHkgbXVs dGlwbHlpbmcuCisKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclN0eWxlOjpzZXRGb250U2l6ZSk6 CisKKyAgICAgICAgICAgIFVzZSBjb21wdXRlQXV0b3NpemVkRm9udFNpemUgaW5zdGVhZCBvZiBk aXJlY3RseSBtdWx0aXBseWluZy4KKwogMjAxMi0wOC0xOCAgUGF2ZWwgRmVsZG1hbiAgPHBmZWxk bWFuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBXZWIgSW5zcGVjdG9yOiBtYWtlIHByb2ZpbGVz IHBhbmVsIGEgbGF6aWx5IGxvYWRlZCBtb2R1bGUuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv VGV4dEF1dG9zaXplci5jcHAKaW5kZXggOTViM2UyOWRjYjg3Y2NjYjYwNTcxZDNlMWEyODM1NWEz NjFjMmQ4ZC4uNzYxY2QyOTcxNTAyZWFmMzU1MjE0YjQxZjJiZDcyMDg3MjhiOGNhNCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcApAQCAtOTIsNiArOTIsMzQg QEAgdm9pZCBUZXh0QXV0b3NpemVyOjpzZXRNdWx0aXBsaWVyKFJlbmRlck9iamVjdCogcmVuZGVy ZXIsIGZsb2F0IG11bHRpcGxpZXIpCiAgICAgcmVuZGVyZXItPnNldFN0eWxlKG5ld1N0eWxlLnJl bGVhc2UoKSk7CiB9CiAKK2Zsb2F0IFRleHRBdXRvc2l6ZXI6OmNvbXB1dGVBdXRvc2l6ZWRGb250 U2l6ZShmbG9hdCBzcGVjaWZpZWRTaXplLCBmbG9hdCBtdWx0aXBsaWVyKQoreworICAgIC8vIFNv bWV3aGF0IGFyYml0cmFyeSAicGxlYXNhbnQiIGZvbnQgc2l6ZS4KKyAgICBjb25zdCBmbG9hdCBw bGVhc2FudFNpemUgPSAxNjsKKworICAgIC8vIE11bHRpcGx5IGZvbnRzIHRoYXQgdGhlIHBhZ2Ug YXV0aG9yIGhhcyBzcGVjaWZpZWQgdG8gYmUgbGFyZ2VyIHRoYW4KKyAgICAvLyBwbGVhc2FudFNp emUgYnkgbGVzcyBhbmQgbGVzcywgdW50aWwgaHVnZSBmb250cyBhcmUgbm90IGluY3JlYXNlZCBh dCBhbGwuCisgICAgLy8gRm9yIHNwZWNpZmllZFNpemUgYmV0d2VlbiAwIGFuZCBwbGVhc2FudFNp emUgd2UgZGlyZWN0bHkgYXBwbHkgdGhlCisgICAgLy8gbXVsdGlwbGllcjsgaGVuY2UgZm9yIHNw ZWNpZmllZFNpemUgPT0gcGxlYXNhbnRTaXplLCBjb21wdXRlZFNpemUgd2lsbCBiZQorICAgIC8v IG11bHRpcGxpZXIgKiBwbGVhc2FudFNpemUuIEZvciBncmVhdGVyIHNwZWNpZmllZFNpemVzIHdl IHdhbnQgdG8KKyAgICAvLyBncmFkdWFsbHkgZmFkZSBvdXQgdGhlIG11bHRpcGxpZXIsIHNvIGZv ciBldmVyeSAxcHggaW5jcmVhc2UgaW4KKyAgICAvLyBzcGVjaWZpZWRTaXplIGJleW9uZCBwbGVh c2FudFNpemUgd2Ugd2lsbCBvbmx5IGluY3JlYXNlIGNvbXB1dGVkU2l6ZQorICAgIC8vIGJ5IGdy YWRpZW50QWZ0ZXJQbGVhc2FudFNpemUgcHggdW50aWwgd2UgbWVldCB0aGUKKyAgICAvLyBjb21w dXRlZFNpemUgPSBzcGVjaWZpZWRTaXplIGxpbmUsIGFmdGVyIHdoaWNoIHdlIHN0YXkgb24gdGhh dCBsaW5lIChzbworICAgIC8vIHRoZW4gZXZlcnkgMXB4IGluY3JlYXNlIGluIHNwZWNpZmllZFNp emUgaW5jcmVhc2VzIGNvbXB1dGVkU2l6ZSBieSAxcHgpLgorICAgIGNvbnN0IGZsb2F0IGdyYWRp ZW50QWZ0ZXJQbGVhc2FudFNpemUgPSAwLjU7CisKKyAgICBmbG9hdCBjb21wdXRlZFNpemU7Cisg ICAgaWYgKHNwZWNpZmllZFNpemUgPD0gcGxlYXNhbnRTaXplKQorICAgICAgICBjb21wdXRlZFNp emUgPSBtdWx0aXBsaWVyICogc3BlY2lmaWVkU2l6ZTsKKyAgICBlbHNlIHsKKyAgICAgICAgY29t cHV0ZWRTaXplID0gbXVsdGlwbGllciAqIHBsZWFzYW50U2l6ZSArIGdyYWRpZW50QWZ0ZXJQbGVh c2FudFNpemUgKiAoc3BlY2lmaWVkU2l6ZSAtIHBsZWFzYW50U2l6ZSk7CisgICAgICAgIGlmIChj b21wdXRlZFNpemUgPCBzcGVjaWZpZWRTaXplKQorICAgICAgICAgICAgY29tcHV0ZWRTaXplID0g c3BlY2lmaWVkU2l6ZTsKKyAgICB9CisgICAgcmV0dXJuIGNvbXB1dGVkU2l6ZTsKK30KKwogYm9v bCBUZXh0QXV0b3NpemVyOjppc05vdEFuQXV0b3NpemluZ0NvbnRhaW5lcihjb25zdCBSZW5kZXJP YmplY3QqIHJlbmRlcmVyKQogewogICAgIC8vICJBdXRvc2l6aW5nIGNvbnRhaW5lcnMiIGFyZSB0 aGUgc21hbGxlc3QgdW5pdCBmb3Igd2hpY2ggd2UgY2FuIGVuYWJsZS9kaXNhYmxlCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oIGIvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaAppbmRleCA0YjBiYzRhOTA1ZWMxM2Q5Nzky NTgyMWIzY2QxMjRhZmQxMjk4NTEyLi40YzY5NTYzOWNiZDQyYmM4NDllMDg0NGE4YTgwZDgzOWUz YTU0ZjZlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXpl ci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmgKQEAgLTUx LDYgKzUxLDggQEAgcHVibGljOgogCiAgICAgYm9vbCBwcm9jZXNzU3VidHJlZShSZW5kZXJPYmpl Y3QqIGxheW91dFJvb3QpOwogCisgICAgc3RhdGljIGZsb2F0IGNvbXB1dGVBdXRvc2l6ZWRGb250 U2l6ZShmbG9hdCBzcGVjaWZpZWRTaXplLCBmbG9hdCBtdWx0aXBsaWVyKTsKKwogcHJpdmF0ZToK ICAgICBleHBsaWNpdCBUZXh0QXV0b3NpemVyKERvY3VtZW50Kik7CiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdHlsZS9SZW5kZXJTdHlsZS5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuY3BwCmluZGV4IDViNGMzYjk5NjcwOTJi YzNhYzgwNDVlNzA2NGE5ZDMwM2M0MmJiNjkuLjUxYmMyYjJkZGRiMzBmYjQwMjdhNDNlOTU4OGVi NjkwMjhjMzY1MGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdHlsZS9S ZW5kZXJTdHlsZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRl clN0eWxlLmNwcApAQCAtNDEsNiArNDEsMTAgQEAKICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFz Lmg+CiAjaW5jbHVkZSA8YWxnb3JpdGhtPgogCisjaWYgRU5BQkxFKFRFWFRfQVVUT1NJWklORykK KyNpbmNsdWRlICJUZXh0QXV0b3NpemVyLmgiCisjZW5kaWYKKwogdXNpbmcgbmFtZXNwYWNlIHN0 ZDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtMTIxNiw3ICsxMjIwLDcgQEAgTGVuZ3RoIFJl bmRlclN0eWxlOjpsaW5lSGVpZ2h0KCkgY29uc3QKICAgICAvLyB0b28sIHRob3VnaCB0aGlzIGlu dm9sdmVzIG1lc3NpbHkgcG9raW5nIGludG8gQ2FsY0V4cHJlc3Npb25MZW5ndGguCiAgICAgZmxv YXQgbXVsdGlwbGllciA9IHRleHRBdXRvc2l6aW5nTXVsdGlwbGllcigpOwogICAgIGlmIChtdWx0 aXBsaWVyID4gMSAmJiBsaC5pc0ZpeGVkKCkpCi0gICAgICAgIHJldHVybiBMZW5ndGgobGgudmFs dWUoKSAqIG11bHRpcGxpZXIsIEZpeGVkKTsKKyAgICAgICAgcmV0dXJuIExlbmd0aChUZXh0QXV0 b3NpemVyOjpjb21wdXRlQXV0b3NpemVkRm9udFNpemUobGgudmFsdWUoKSwgbXVsdGlwbGllciks IEZpeGVkKTsKICNlbmRpZgogICAgIHJldHVybiBsaDsKIH0KQEAgLTEyNTUsOCArMTI1OSw3IEBA IHZvaWQgUmVuZGVyU3R5bGU6OnNldEZvbnRTaXplKGZsb2F0IHNpemUpCiAjaWYgRU5BQkxFKFRF WFRfQVVUT1NJWklORykKICAgICBmbG9hdCBtdWx0aXBsaWVyID0gdGV4dEF1dG9zaXppbmdNdWx0 aXBsaWVyKCk7CiAgICAgaWYgKG11bHRpcGxpZXIgPiAxKSB7Ci0gICAgICAgIC8vIEZJWE1FOiBM YXJnZSBmb250IHNpemVzIG5lZWRuJ3QgYmUgbXVsdGlwbGllZCBhcyBtdWNoIHNpbmNlIHRoZXkg YXJlIGFscmVhZHkgbW9yZSBsZWdpYmxlLgotICAgICAgICBkZXNjLnNldENvbXB1dGVkU2l6ZShz aXplICogbXVsdGlwbGllcik7CisgICAgICAgIGRlc2Muc2V0Q29tcHV0ZWRTaXplKFRleHRBdXRv c2l6ZXI6OmNvbXB1dGVBdXRvc2l6ZWRGb250U2l6ZShzaXplLCBtdWx0aXBsaWVyKSk7CiAgICAg fQogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRl c3RzL0NoYW5nZUxvZwppbmRleCA2N2U3ODI3NDVmNTM3NGRmMzFlYTExYWQwOTdmNzQ4YzUxMDM1 OGVlLi4wY2U2NmU4Yjk1MzhkYmNmOGMwMDJlMTBkNWNiYzVmNjc4YmI0Y2YzIDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTUgQEAKKzIwMTItMDgtMjMgIEpvaG4gTWVsbG9yICA8am9obm1lQGNocm9taXVtLm9y Zz4KKworICAgICAgICBUZXh0IEF1dG9zaXppbmc6IE11bHRpcGx5IGxhcmdlIGZvbnRzIGxlc3Ms IGFzIHRoZXkgYXJlIGFscmVhZHkgbW9yZSBsZWdpYmxlLgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTQyMjcKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCB0ZXN0IGRlbW9uc3RyYXRpbmcgaG93IHZh cmlvdXMgZm9udCBzaXplcyBhcmUgYWZmZWN0ZWQuCisKKyAgICAgICAgKiBmYXN0L3RleHQtYXV0 b3NpemluZy92YXJpb3VzLWZvbnQtc2l6ZXMtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAg ICogZmFzdC90ZXh0LWF1dG9zaXppbmcvdmFyaW91cy1mb250LXNpemVzLmh0bWw6IEFkZGVkLgor CiAyMDEyLTA4LTE4ICBQYXZlbCBGZWxkbWFuICA8cGZlbGRtYW5AY2hyb21pdW0ub3JnPgogCiAg ICAgICAgIFdlYiBJbnNwZWN0b3I6IG1ha2UgcHJvZmlsZXMgcGFuZWwgYSBsYXppbHkgbG9hZGVk IG1vZHVsZS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL3Zh cmlvdXMtZm9udC1zaXplcy1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1 dG9zaXppbmcvdmFyaW91cy1mb250LXNpemVzLWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODcy MzYxZTcyMTZhMjAwNGRiMzM3NmJiOGVlMDhkOWM5Zjg3YjMxYgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL3ZhcmlvdXMtZm9udC1zaXplcy1leHBl Y3RlZC5odG1sCkBAIC0wLDAgKzEsMjcgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVh ZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGUg dHlwZT0idGV4dC9jc3MiPgorYm9keSB7IHdpZHRoOiA4MDBweDsgbWFyZ2luOiAwOyB9Cis8L3N0 eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyMHB4Ij4K KyAgICBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcg ZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9y ZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlzIG5vc3RydWQgZXhl cmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1aXAgZXggZWEgY29tbW9kbyBj b25zZXF1YXQuCis8L2Rpdj4KKzxkaXYgc3R5bGU9ImZvbnQtc2l6ZTogNDBweCI+CisgICAgTG9y ZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNl ZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEg YWxpcXVhLgorPC9kaXY+Cis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDQ4cHgiPgorICAgIExvcmVt IGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQg ZG8gZWl1c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hLgor PC9kaXY+Cis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDU2cHgiPgorICAgIExvcmVtIGlwc3VtIGRv bG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21v ZCB0ZW1wb3IgaW5jaWRpZHVudCB1dC4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy92YXJpb3VzLWZvbnQtc2l6 ZXMuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL3ZhcmlvdXMtZm9udC1z aXplcy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLmI4NDY5Mjc4Njk3Y2RjMTJjMTM2YmY0Zjc0ODRkZGIyZWRh Y2I5NTEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3Npemlu Zy92YXJpb3VzLWZvbnQtc2l6ZXMuaHRtbApAQCAtMCwwICsxLDM2IEBACis8IURPQ1RZUEUgaHRt bD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0 aD04MDAiPgorPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KK2JvZHkgeyB3aWR0aDogODAwcHg7IG1h cmdpbjogMDsgfQorPC9zdHlsZT4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgor aWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNl dFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRp bmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30gZWxz ZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29uc29sZS53YXJu KCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVpbmcg dHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUgVGV4 dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBweCBk ZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19GT1JD RV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hlYWQ+ Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiA4cHgiPgorICAgIExvcmVtIGlwc3Vt IGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1 c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4g VXQgZW5pbSBhZCBtaW5pbSB2ZW5pYW0sIHF1aXMgbm9zdHJ1ZCBleGVyY2l0YXRpb24gdWxsYW1j byBsYWJvcmlzIG5pc2kgdXQgYWxpcXVpcCBleCBlYSBjb21tb2RvIGNvbnNlcXVhdC4KKzwvZGl2 PgorPGRpdiBzdHlsZT0iZm9udC1zaXplOiAxNnB4Ij4KKyAgICBMb3JlbSBpcHN1bSBkb2xvciBz aXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVt cG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4K KzxkaXYgc3R5bGU9ImZvbnQtc2l6ZTogMzJweCI+CisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0 IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBv ciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEuCis8L2Rpdj4KKzxkaXYgc3R5 bGU9ImZvbnQtc2l6ZTogNDhweCI+CisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNv bnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlk dW50IHV0LgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4K