Changeset 167735 in webkit


Ignore:
Timestamp:
Apr 23, 2014 7:13:06 PM (10 years ago)
Author:
benjamin@webkit.org
Message:

[iOS][WK2] Fix a few mistakes affecting the initial layout and the initial unobscured rect
​https://bugs.webkit.org/show_bug.cgi?id=132093

Source/WebCore:

Patch by Benjamin Poulain <​bpoulain@apple.com> on 2014-04-23
Reviewed by Tim Horton.

Change the minimum layout size to float point values to account for size defined on retina displays.
The minimum layout size supports half-pixels, the value is rounded later when computing the layout size
in document coordinates.

  • WebCore.exp.in:
  • page/ViewportConfiguration.cpp:

(WebCore::ViewportConfiguration::ViewportConfiguration):
Setting the initial content size is incorrect. The layout size computation already take into account
empty size for the first layout.

Setting the content size upfront make the first computation incorrect when the viewport arguments specify
the initial scale.

(WebCore::ViewportConfiguration::setMinimumLayoutSize):

  • page/ViewportConfiguration.h:

(WebCore::ViewportConfiguration::minimumLayoutSize):

Source/WebKit2:
<rdar://problem/16703237>

Patch by Benjamin Poulain <​bpoulain@apple.com> on 2014-04-23
Reviewed by Tim Horton.

The user of WKWebView can setup a size on device pixels, which can add half a point to the minimum
layout size. By rounding this up before applying the page scale, we ended up with rounding errors
on the layout size and the transitory unobscured content rect.

This patch fixes changes the minimal layout size to float point values to reduce the rounding problems.

  • UIProcess/API/Cocoa/WKWebView.mm:

(setViewportConfigurationMinimumLayoutSize):
(-[WKWebView _setMinimumLayoutSizeOverrideForMinimalUI:]):
(-[WKWebView _beginAnimatedResizeWithUpdates:]):

  • UIProcess/WebPageProxy.h:
  • UIProcess/ios/WebPageProxyIOS.mm:

(WebKit::WebPageProxy::dynamicViewportSizeUpdate):
(WebKit::WebPageProxy::setViewportConfigurationMinimumLayoutSize):
(WebKit::WebPageProxy::setMinimumLayoutSizeForMinimalUI):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::didCommitLoad):
Defaulting the content size to the minimum layout size only works if the initial-scale is 1.
ViewportConfiguration knows exactly what to do before the first layout.

  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebPage/WebPage.messages.in:
  • WebProcess/WebPage/ios/WebPageIOS.mm:

(WebKit::WebPage::setViewportConfigurationMinimumLayoutSize):
(WebKit::WebPage::setMinimumLayoutSizeForMinimalUI):
(WebKit::WebPage::dynamicViewportSizeUpdate):
A few fixes here:
-setZoomedOutPageScaleFactor() was incorrectly using the initial scale. 99% of the time, initial scale

and minimum scale are equal, but the page can specify something different with the viewport meta tag.

-Use floating point for manipulating the minimum layout sizes, then round the value.
-minimumLayoutSizeInDocumentCoordinate was scaled the wrong way around.

(WebKit::WebPage::viewportConfigurationChanged):

Location:
trunk/Source
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r167734 r167735  
     12014-04-23  Benjamin Poulain  <bpoulain@apple.com>
     2
     3        [iOS][WK2] Fix a few mistakes affecting the initial layout and the initial unobscured rect
     4        https://bugs.webkit.org/show_bug.cgi?id=132093
     5
     6        Reviewed by Tim Horton.
     7
     8        Change the minimum layout size to float point values to account for size defined on retina displays.
     9        The minimum layout size supports half-pixels, the value is rounded later when computing the layout size
     10        in document coordinates.
     11
     12        * WebCore.exp.in:
     13        * page/ViewportConfiguration.cpp:
     14        (WebCore::ViewportConfiguration::ViewportConfiguration):
     15        Setting the initial content size is incorrect. The layout size computation already take into account
     16        empty size for the first layout.
     17
     18        Setting the content size upfront make the first computation incorrect when the viewport arguments specify
     19        the initial scale.
     20
     21        (WebCore::ViewportConfiguration::setMinimumLayoutSize):
     22        * page/ViewportConfiguration.h:
     23        (WebCore::ViewportConfiguration::minimumLayoutSize):
     24
    1252014-04-23  Brent Fulgham  <bfulgham@apple.com>
    226

  • trunk/Source/WebCore/WebCore.exp.in

    r167706 r167735  
    895895__ZN7WebCore21ViewportConfiguration15setContentsSizeERKNS_7IntSizeE
    896896__ZN7WebCore21ViewportConfiguration17webpageParametersEv
    897 __ZN7WebCore21ViewportConfiguration20setMinimumLayoutSizeERKNS_7IntSizeE
     897__ZN7WebCore21ViewportConfiguration20setMinimumLayoutSizeERKNS_9FloatSizeE
    898898__ZN7WebCore21ViewportConfiguration20setViewportArgumentsERKNS_17ViewportArgumentsE
    899899__ZN7WebCore21ViewportConfiguration21xhtmlMobileParametersEv

  • trunk/Source/WebCore/page/ViewportConfiguration.cpp

    r167481 r167735  
    4444
    4545ViewportConfiguration::ViewportConfiguration()
    46     : m_contentSize(1024, 768)
    47     , m_minimumLayoutSize(m_contentSize)
     46    : m_minimumLayoutSize(1024, 768)
    4847{
    4948    // Setup a reasonable default configuration to avoid computing infinite scale/sizes.
    … …  
    7372}
    7473
    75 void ViewportConfiguration::setMinimumLayoutSize(const IntSize& minimumLayoutSize)
     74void ViewportConfiguration::setMinimumLayoutSize(const FloatSize& minimumLayoutSize)
    7675{
    7776    if (m_minimumLayoutSize == minimumLayoutSize)

  • trunk/Source/WebCore/page/ViewportConfiguration.h

    r163980 r167735  
    2727#define ViewportConfiguration_h
    2828
     29#include "FloatSize.h"
    2930#include "IntSize.h"
    3031#include "ViewportArguments.h"
    … …  
    7172    void setContentsSize(const IntSize&);
    7273
    73     const IntSize& minimumLayoutSize() const { return m_minimumLayoutSize; }
    74     void setMinimumLayoutSize(const IntSize&);
     74    const FloatSize& minimumLayoutSize() const { return m_minimumLayoutSize; }
     75    void setMinimumLayoutSize(const FloatSize&);
    7576
    7677    const ViewportArguments& viewportArguments() const { return m_viewportArguments; }
    … …  
    9697    Parameters m_defaultConfiguration;
    9798    IntSize m_contentSize;
    98     IntSize m_minimumLayoutSize;
     99    FloatSize m_minimumLayoutSize;
    99100    ViewportArguments m_viewportArguments;
    100101};

  • trunk/Source/WebKit2/ChangeLog

    r167719 r167735  
     12014-04-23  Benjamin Poulain  <bpoulain@apple.com>
     2
     3        [iOS][WK2] Fix a few mistakes affecting the initial layout and the initial unobscured rect
     4        https://bugs.webkit.org/show_bug.cgi?id=132093
     5        <rdar://problem/16703237>
     6
     7        Reviewed by Tim Horton.
     8
     9        The user of WKWebView can setup a size on device pixels, which can add half a point to the minimum
     10        layout size. By rounding this up before applying the page scale, we ended up with rounding errors
     11        on the layout size and the transitory unobscured content rect.
     12
     13        This patch fixes changes the minimal layout size to float point values to reduce the rounding problems.
     14
     15        * UIProcess/API/Cocoa/WKWebView.mm:
     16        (setViewportConfigurationMinimumLayoutSize):
     17        (-[WKWebView _setMinimumLayoutSizeOverrideForMinimalUI:]):
     18        (-[WKWebView _beginAnimatedResizeWithUpdates:]):
     19        * UIProcess/WebPageProxy.h:
     20        * UIProcess/ios/WebPageProxyIOS.mm:
     21        (WebKit::WebPageProxy::dynamicViewportSizeUpdate):
     22        (WebKit::WebPageProxy::setViewportConfigurationMinimumLayoutSize):
     23        (WebKit::WebPageProxy::setMinimumLayoutSizeForMinimalUI):
     24
     25        * WebProcess/WebPage/WebPage.cpp:
     26        (WebKit::WebPage::didCommitLoad):
     27        Defaulting the content size to the minimum layout size only works if the initial-scale is 1.
     28        ViewportConfiguration knows exactly what to do before the first layout.
     29
     30        * WebProcess/WebPage/WebPage.h:
     31        * WebProcess/WebPage/WebPage.messages.in:
     32        * WebProcess/WebPage/ios/WebPageIOS.mm:
     33        (WebKit::WebPage::setViewportConfigurationMinimumLayoutSize):
     34        (WebKit::WebPage::setMinimumLayoutSizeForMinimalUI):
     35        (WebKit::WebPage::dynamicViewportSizeUpdate):
     36        A few fixes here:
     37        -setZoomedOutPageScaleFactor() was incorrectly using the initial scale. 99% of the time, initial scale
     38         and minimum scale are equal, but the page can specify something different with the viewport meta tag.
     39        -Use floating point for manipulating the minimum layout sizes, then round the value.
     40        -minimumLayoutSizeInDocumentCoordinate was scaled the wrong way around.
     41
     42        (WebKit::WebPage::viewportConfigurationChanged):
     43
    1442014-04-23  Yongjun Zhang  <yongjun_zhang@apple.com>
    245

  • trunk/Source/WebKit2/UIProcess/API/Cocoa/WKWebView.mm

    r167616 r167735  
    721721static inline void setViewportConfigurationMinimumLayoutSize(WebKit::WebPageProxy& page, const CGSize& size)
    722722{
    723     page.setViewportConfigurationMinimumLayoutSize(WebCore::IntSize(CGCeiling(size.width), CGCeiling(size.height)));
     723    page.setViewportConfigurationMinimumLayoutSize(WebCore::FloatSize(size));
    724724}
    725725
    … …  
    12801280    _minimumLayoutSizeOverrideForMinimalUI = size;
    12811281    if (!_isAnimatingResize)
    1282         _page->setMinimumLayoutSizeForMinimalUI(WebCore::IntSize(CGCeiling(size.width), CGCeiling(size.height)));
     1282        _page->setMinimumLayoutSizeForMinimalUI(WebCore::FloatSize(size));
    12831283}
    12841284
    … …  
    13941394    CGRect unobscuredRectInContentCoordinates = [self convertRect:unobscuredRect toView:_contentView.get()];
    13951395
    1396     _page->dynamicViewportSizeUpdate(WebCore::IntSize(CGCeiling(newMinimumLayoutSize.width), CGCeiling(newMinimumLayoutSize.height)), visibleRectInContentCoordinates, unobscuredRectInContentCoordinates, targetScale);
     1396    _page->dynamicViewportSizeUpdate(WebCore::FloatSize(newMinimumLayoutSize.width, newMinimumLayoutSize.height), visibleRectInContentCoordinates, unobscuredRectInContentCoordinates, targetScale);
    13971397}
    13981398

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.h

    r167698 r167735  
    577577    uint64_t lastVisibleContentRectUpdateID() const { return m_lastVisibleContentRectUpdate.updateID(); }
    578578
    579     void dynamicViewportSizeUpdate(const WebCore::IntSize& minimumLayoutSize, const WebCore::FloatRect& targetExposedContentRect, const WebCore::FloatRect& targetUnobscuredRect, double targetScale);
     579    void dynamicViewportSizeUpdate(const WebCore::FloatSize& minimumLayoutSize, const WebCore::FloatRect& targetExposedContentRect, const WebCore::FloatRect& targetUnobscuredRect, double targetScale);
    580580   
    581     void setViewportConfigurationMinimumLayoutSize(const WebCore::IntSize&);
    582     void setMinimumLayoutSizeForMinimalUI(const WebCore::IntSize&);
     581    void setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize&);
     582    void setMinimumLayoutSizeForMinimalUI(const WebCore::FloatSize&);
    583583    void didCommitLayerTree(const WebKit::RemoteLayerTreeTransaction&);
    584584

  • trunk/Source/WebKit2/UIProcess/ios/WebPageProxyIOS.mm

    r167616 r167735  
    189189}
    190190
    191 void WebPageProxy::dynamicViewportSizeUpdate(const IntSize& minimumLayoutSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, double targetScale)
     191void WebPageProxy::dynamicViewportSizeUpdate(const FloatSize& minimumLayoutSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, double targetScale)
    192192{
    193193    m_process->send(Messages::WebPage::DynamicViewportSizeUpdate(minimumLayoutSize, targetExposedContentRect, targetUnobscuredRect, targetScale), m_pageID);
    194194}
    195195
    196 void WebPageProxy::setViewportConfigurationMinimumLayoutSize(const WebCore::IntSize& size)
     196void WebPageProxy::setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize& size)
    197197{
    198198    m_process->send(Messages::WebPage::SetViewportConfigurationMinimumLayoutSize(size), m_pageID);
    199199}
    200200
    201 void WebPageProxy::setMinimumLayoutSizeForMinimalUI(const WebCore::IntSize& size)
     201void WebPageProxy::setMinimumLayoutSizeForMinimalUI(const WebCore::FloatSize& size)
    202202{
    203203    m_process->send(Messages::WebPage::SetMinimumLayoutSizeForMinimalUI(size), m_pageID);

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r167698 r167735  
    42644264
    42654265    m_viewportConfiguration.setViewportArguments(ViewportArguments());
    4266     m_viewportConfiguration.setContentsSize(m_viewportConfiguration.minimumLayoutSize());
     4266    m_viewportConfiguration.setContentsSize(IntSize());
    42674267    viewportConfigurationChanged();
    42684268#endif

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.h

    r167698 r167735  
    696696
    697697#if PLATFORM(IOS)
    698     void setViewportConfigurationMinimumLayoutSize(const WebCore::IntSize&);
    699     void setMinimumLayoutSizeForMinimalUI(const WebCore::IntSize&);
    700     void dynamicViewportSizeUpdate(const WebCore::IntSize& minimumLayoutSize, const WebCore::FloatRect& targetExposedContentRect, const WebCore::FloatRect& targetUnobscuredRect, double scale);
     698    void setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize&);
     699    void setMinimumLayoutSizeForMinimalUI(const WebCore::FloatSize&);
     700    void dynamicViewportSizeUpdate(const WebCore::FloatSize& minimumLayoutSize, const WebCore::FloatRect& targetExposedContentRect, const WebCore::FloatRect& targetUnobscuredRect, double scale);
    701701    void viewportConfigurationChanged();
    702702    void updateVisibleContentRects(const VisibleContentRectUpdateInfo&);
    … …  
    11661166    WebCore::FloatSize m_availableScreenSize;
    11671167    WebCore::IntSize m_blockSelectionDesiredSize;
    1168     WebCore::IntSize m_minimumLayoutSizeForMinimalUI;
     1168    WebCore::FloatSize m_minimumLayoutSizeForMinimalUI;
    11691169    bool m_inDynamicSizeUpdate;
    11701170    HashMap<std::pair<WebCore::IntSize, double>, WebCore::IntPoint> m_dynamicSizeUpdateHistory;

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.messages.in

    r167698 r167735  
    4444    WheelEventSyncForTesting(WebKit::WebWheelEvent event) -> (bool handled)
    4545#if PLATFORM(IOS)
    46     SetViewportConfigurationMinimumLayoutSize(WebCore::IntSize size)
    47     SetMinimumLayoutSizeForMinimalUI(WebCore::IntSize size)
    48     DynamicViewportSizeUpdate(WebCore::IntSize minimumLayoutSize, WebCore::FloatRect targetExposedContentRect, WebCore::FloatRect targetUnobscuredRect, double scale)
     46    SetViewportConfigurationMinimumLayoutSize(WebCore::FloatSize size)
     47    SetMinimumLayoutSizeForMinimalUI(WebCore::FloatSize size)
     48    DynamicViewportSizeUpdate(WebCore::FloatSize minimumLayoutSize, WebCore::FloatRect targetExposedContentRect, WebCore::FloatRect targetUnobscuredRect, double scale)
    4949
    5050    HandleTap(WebCore::IntPoint point)

  • trunk/Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm

    r167698 r167735  
    17601760}
    17611761
    1762 void WebPage::setViewportConfigurationMinimumLayoutSize(const IntSize& size)
     1762void WebPage::setViewportConfigurationMinimumLayoutSize(const FloatSize& size)
    17631763{
    17641764    m_viewportConfiguration.setMinimumLayoutSize(size);
    … …  
    17661766}
    17671767
    1768 void WebPage::setMinimumLayoutSizeForMinimalUI(const IntSize& size)
     1768void WebPage::setMinimumLayoutSizeForMinimalUI(const FloatSize& size)
    17691769{
    17701770    m_minimumLayoutSizeForMinimalUI = size;
    … …  
    17721772}
    17731773
    1774 void WebPage::dynamicViewportSizeUpdate(const IntSize& minimumLayoutSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, double targetScale)
     1774void WebPage::dynamicViewportSizeUpdate(const FloatSize& minimumLayoutSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, double targetScale)
    17751775{
    17761776    TemporaryChange<bool> dynamicSizeUpdateGuard(m_inDynamicSizeUpdate, true);
    … …  
    19311931        scale = initialScale;
    19321932
    1933     m_page->setZoomedOutPageScaleFactor(initialScale);
    1934    
     1933    m_page->setZoomedOutPageScaleFactor(m_viewportConfiguration.minimumScale());
     1934
    19351935    FrameView& frameView = *mainFrameView();
    1936     IntSize viewportSize = !m_minimumLayoutSizeForMinimalUI.isEmpty() ? m_minimumLayoutSizeForMinimalUI : m_viewportConfiguration.minimumLayoutSize();
     1936    FloatSize viewportSize = !m_minimumLayoutSizeForMinimalUI.isEmpty() ? m_minimumLayoutSizeForMinimalUI : m_viewportConfiguration.minimumLayoutSize();
    19371937    viewportSize.scale(1 / initialScale);
    1938     frameView.setViewportSize(viewportSize);
     1938    frameView.setViewportSize(roundedIntSize(viewportSize));
    19391939   
    19401940    IntPoint scrollPosition = frameView.scrollPosition();
    19411941    if (!m_hasReceivedVisibleContentRectsAfterDidCommitLoad) {
    1942         IntSize minimumLayoutSizeInDocumentCoordinate = m_viewportConfiguration.minimumLayoutSize();
    1943         minimumLayoutSizeInDocumentCoordinate.scale(scale);
    1944 
    1945         IntRect unobscuredContentRect(scrollPosition, minimumLayoutSizeInDocumentCoordinate);
     1942        FloatSize minimumLayoutSizeInScrollViewCoordinates = m_viewportConfiguration.minimumLayoutSize();
     1943        minimumLayoutSizeInScrollViewCoordinates.scale(1 / scale);
     1944        IntSize minimumLayoutSizeInDocumentCoordinates = roundedIntSize(minimumLayoutSizeInScrollViewCoordinates);
     1945        IntRect unobscuredContentRect(scrollPosition, minimumLayoutSizeInDocumentCoordinates);
    19461946        frameView.setUnobscuredContentRect(unobscuredContentRect);
    19471947        frameView.setScrollVelocity(0, 0, 0, monotonicallyIncreasingTime());
Note: See TracChangeset for help on using the changeset viewer.