Changeset 139189 in webkit


Ignore:
Timestamp:
Jan 9, 2013, 5:59:48 AM (12 years ago)
Author:
abecsi@webkit.org
Message:

[Qt][EFL][WK2] Remove redundant device pixel ratio adjustment from PageViewportController
​https://bugs.webkit.org/show_bug.cgi?id=106355

Reviewed by Kenneth Rohde Christiansen.

Since r137597 Qt uses the device pixel ratio of the underlying
platform window as the device pixel ratio in WebCore.
The tiles are rendered with the effective scale (scale adjusted with
the device scale factor) and the projection matrix is also adjusted
with the device pixel ratio when painting.
As a result we can follow the same approach as QtQuick and all the
coordinates in PageViewportController need to be in device independent
pixels (UI pixels) thus we do no longer need to adjust with the device
pixel ratio when calculating the viewport attributes.
This simplifies the logic significantly and increases robustness,
but does not allow to set a custom device pixel ratio different from
the factor of the underlying platform (eg. for testing purposes).
This patch is conceptually a follow-up of r137597 and fixes layout
and canvas size on retina display.

  • UIProcess/PageViewportController.cpp:

(WebKit::PageViewportController::PageViewportController):
(WebKit::PageViewportController::innerBoundedViewportScale):
(WebKit::PageViewportController::outerBoundedViewportScale):
(WebKit::PageViewportController::pixelAlignedFloatPoint):
(WebKit::PageViewportController::boundContentsPosition):
(WebKit::PageViewportController::didRenderFrame):
(WebKit::PageViewportController::pageTransitionViewportReady):
(WebKit::PageViewportController::didChangeContentsVisibility):
(WebKit::PageViewportController::syncVisibleContents):
(WebKit::PageViewportController::visibleContentsSize):
(WebKit::PageViewportController::applyScaleAfterRenderingContents):
(WebKit::PageViewportController::updateMinimumScaleToFit):

  • UIProcess/PageViewportController.h:

(WebKit::PageViewportController::currentContentsScale):
(PageViewportController):

  • UIProcess/efl/PageViewportControllerClientEfl.cpp:

(WebKit::PageViewportControllerClientEfl::updateViewportSize):
Adjust the viewport size with the device pixel ratio to keep previous
behaviour.

  • UIProcess/qt/PageViewportControllerClientQt.cpp:

(WebKit::PageViewportControllerClientQt::focusEditableArea):
(WebKit::PageViewportControllerClientQt::zoomToAreaGestureEnded):

  • UIProcess/qt/QtWebPageSGNode.cpp:

(WebKit::ContentsSGNode::clipRect):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::sendViewportAttributesChanged):

Location:
trunk/Source/WebKit2
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r139184 r139189  
     12013-01-09  Andras Becsi  <andras.becsi@digia.com>
     2
     3        [Qt][EFL][WK2] Remove redundant device pixel ratio adjustment from PageViewportController
     4        https://bugs.webkit.org/show_bug.cgi?id=106355
     5
     6        Reviewed by Kenneth Rohde Christiansen.
     7
     8        Since r137597 Qt uses the device pixel ratio of the underlying
     9        platform window as the device pixel ratio in WebCore.
     10        The tiles are rendered with the effective scale (scale adjusted with
     11        the device scale factor) and the projection matrix is also adjusted
     12        with the device pixel ratio when painting.
     13        As a result we can follow the same approach as QtQuick and all the
     14        coordinates in PageViewportController need to be in device independent
     15        pixels (UI pixels) thus we do no longer need to adjust with the device
     16        pixel ratio when calculating the viewport attributes.
     17        This simplifies the logic significantly and increases robustness,
     18        but does not allow to set a custom device pixel ratio different from
     19        the factor of the underlying platform (eg. for testing purposes).
     20        This patch is conceptually a follow-up of r137597 and fixes layout
     21        and canvas size on retina display.
     22
     23        * UIProcess/PageViewportController.cpp:
     24        (WebKit::PageViewportController::PageViewportController):
     25        (WebKit::PageViewportController::innerBoundedViewportScale):
     26        (WebKit::PageViewportController::outerBoundedViewportScale):
     27        (WebKit::PageViewportController::pixelAlignedFloatPoint):
     28        (WebKit::PageViewportController::boundContentsPosition):
     29        (WebKit::PageViewportController::didRenderFrame):
     30        (WebKit::PageViewportController::pageTransitionViewportReady):
     31        (WebKit::PageViewportController::didChangeContentsVisibility):
     32        (WebKit::PageViewportController::syncVisibleContents):
     33        (WebKit::PageViewportController::visibleContentsSize):
     34        (WebKit::PageViewportController::applyScaleAfterRenderingContents):
     35        (WebKit::PageViewportController::updateMinimumScaleToFit):
     36        * UIProcess/PageViewportController.h:
     37        (WebKit::PageViewportController::currentContentsScale):
     38        (PageViewportController):
     39        * UIProcess/efl/PageViewportControllerClientEfl.cpp:
     40        (WebKit::PageViewportControllerClientEfl::updateViewportSize):
     41        Adjust the viewport size with the device pixel ratio to keep previous
     42        behaviour.
     43        * UIProcess/qt/PageViewportControllerClientQt.cpp:
     44        (WebKit::PageViewportControllerClientQt::focusEditableArea):
     45        (WebKit::PageViewportControllerClientQt::zoomToAreaGestureEnded):
     46        * UIProcess/qt/QtWebPageSGNode.cpp:
     47        (WebKit::ContentsSGNode::clipRect):
     48        * WebProcess/WebPage/WebPage.cpp:
     49        (WebKit::WebPage::sendViewportAttributesChanged):
     50
    1512013-01-09  Carlos Garcia Campos  <cgarcia@igalia.com>
    252

  • trunk/Source/WebKit2/UIProcess/PageViewportController.cpp

    r138149 r139189  
    4848    , m_hasSuspendedContent(false)
    4949    , m_hadUserInteraction(false)
    50     , m_effectiveScale(1)
     50    , m_contentsScale(1)
    5151    , m_pendingPositionChange(false)
    5252    , m_pendingScaleChange(false)
    … …  
    6969float PageViewportController::innerBoundedViewportScale(float viewportScale) const
    7070{
    71     return clampTo(viewportScale, toViewportScale(m_minimumScaleToFit), toViewportScale(m_rawAttributes.maximumScale));
     71    return clampTo(viewportScale, m_minimumScaleToFit, m_rawAttributes.maximumScale);
    7272}
    7373
    … …  
    7676    if (m_allowsUserScaling) {
    7777        // Bounded by [0.1, 10.0] like the viewport meta code in WebCore.
    78         float hardMin = toViewportScale(std::max<float>(0.1, 0.5 * m_minimumScaleToFit));
    79         float hardMax = toViewportScale(std::min<float>(10, 2 * m_rawAttributes.maximumScale));
     78        float hardMin = std::max<float>(0.1, 0.5 * m_minimumScaleToFit);
     79        float hardMax = std::min<float>(10, 2 * m_rawAttributes.maximumScale);
    8080        return clampTo(viewportScale, hardMin, hardMax);
    8181    }
    … …  
    9696{
    9797#if PLATFORM(EFL)
    98     if (!isIntegral(m_effectiveScale)) {
     98    if (!isIntegral(m_contentsScale)) {
    9999        // To avoid blurryness, modify the position so that it maps into a discrete device position.
    100100        FloatPoint scaledPos(framePosition);
    101101
    102102        // Scale by the effective scale factor to compute the screen-relative position.
    103         scaledPos.scale(m_effectiveScale, m_effectiveScale);
     103        scaledPos.scale(m_contentsScale, m_contentsScale);
    104104
    105105        // Round to integer boundaries.
    … …  
    107107
    108108        // Convert back to CSS coordinates.
    109         alignedPos.scale(1 / m_effectiveScale, 1 / m_effectiveScale);
     109        alignedPos.scale(1 / m_contentsScale, 1 / m_contentsScale);
    110110
    111111        return alignedPos;
    … …  
    134134FloatPoint PageViewportController::boundContentsPosition(const WebCore::FloatPoint& framePosition)
    135135{
    136     return boundContentsPositionAtScale(framePosition, m_effectiveScale);
     136    return boundContentsPositionAtScale(framePosition, m_contentsScale);
    137137}
    138138
    … …  
    190190    if (m_pendingScaleChange) {
    191191        m_pendingScaleChange = false;
    192         m_client->setContentsScale(m_effectiveScale);
     192        m_client->setContentsScale(m_contentsScale);
    193193
    194194        // The scale changed, we have to re-pixel align.
    … …  
    212212        m_hadUserInteraction = false;
    213213        float initialScale = m_initiallyFitToViewport ? m_minimumScaleToFit : m_rawAttributes.initialScale;
    214         applyScaleAfterRenderingContents(innerBoundedViewportScale(toViewportScale(initialScale)));
     214        applyScaleAfterRenderingContents(innerBoundedViewportScale(initialScale));
    215215    }
    216216
    … …  
    257257        m_contentsPosition = position;
    258258    if (!m_pendingScaleChange)
    259         m_effectiveScale = scale;
     259        m_contentsScale = scale;
    260260
    261261    syncVisibleContents(trajectoryVector);
    … …  
    270270    FloatRect visibleContentsRect(boundContentsPosition(m_contentsPosition), visibleContentsSize());
    271271    visibleContentsRect.intersect(FloatRect(FloatPoint::zero(), m_contentsSize));
    272     drawingArea->setVisibleContentsRect(visibleContentsRect, m_effectiveScale, trajectoryVector);
     272    drawingArea->setVisibleContentsRect(visibleContentsRect, m_contentsScale, trajectoryVector);
    273273
    274274    m_client->didChangeVisibleContents();
    … …  
    300300FloatSize PageViewportController::visibleContentsSize() const
    301301{
    302     return FloatSize(m_viewportSize.width() / m_effectiveScale, m_viewportSize.height() / m_effectiveScale);
     302    return FloatSize(m_viewportSize.width() / m_contentsScale, m_viewportSize.height() / m_contentsScale);
    303303}
    304304
    … …  
    325325void PageViewportController::applyScaleAfterRenderingContents(float scale)
    326326{
    327     m_effectiveScale = scale;
     327    m_contentsScale = scale;
    328328    m_pendingScaleChange = true;
    329329    syncVisibleContents();
    … …  
    342342        return false;
    343343
    344     bool currentlyScaledToFit = fuzzyCompare(m_effectiveScale, toViewportScale(m_minimumScaleToFit), 0.0001);
    345 
    346     float minimumScale = WebCore::computeMinimumScaleFactorForContentContained(m_rawAttributes, WebCore::roundedIntSize(m_viewportSize), WebCore::roundedIntSize(m_contentsSize), devicePixelRatio());
     344    bool currentlyScaledToFit = fuzzyCompare(m_contentsScale, m_minimumScaleToFit, 0.0001);
     345
     346    float minimumScale = WebCore::computeMinimumScaleFactorForContentContained(m_rawAttributes, WebCore::roundedIntSize(m_viewportSize), WebCore::roundedIntSize(m_contentsSize), 1);
    347347
    348348    if (minimumScale <= 0)
    … …  
    354354        if (!hasSuspendedContent()) {
    355355            if (!m_hadUserInteraction || (userInitiatedUpdate && currentlyScaledToFit))
    356                 applyScaleAfterRenderingContents(toViewportScale(m_minimumScaleToFit));
     356                applyScaleAfterRenderingContents(m_minimumScaleToFit);
    357357            else {
    358358                // Ensure the effective scale stays within bounds.
    359                 float boundedScale = innerBoundedViewportScale(m_effectiveScale);
    360                 if (!fuzzyCompare(boundedScale, m_effectiveScale, 0.0001))
     359                float boundedScale = innerBoundedViewportScale(m_contentsScale);
     360                if (!fuzzyCompare(boundedScale, m_contentsScale, 0.0001))
    361361                    applyScaleAfterRenderingContents(boundedScale);
    362362            }

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

    r137304 r139189  
    6969    float minimumContentsScale() const { return m_minimumScaleToFit; }
    7070    float maximumContentsScale() const { return m_rawAttributes.maximumScale; }
    71     float currentContentsScale() const { return fromViewportScale(m_effectiveScale); }
     71    float currentContentsScale() const { return m_contentsScale; }
    7272
    7373    void setHadUserInteraction(bool didUserInteract) { m_hadUserInteraction = didUserInteract; }
    … …  
    8686
    8787private:
    88     float fromViewportScale(float scale) const { return scale / devicePixelRatio(); }
    89     float toViewportScale(float scale) const { return scale * devicePixelRatio(); }
    9088    void syncVisibleContents(const WebCore::FloatPoint &trajectoryVector = WebCore::FloatPoint::zero());
    9189    void applyScaleAfterRenderingContents(float scale);
    … …  
    109107    WebCore::FloatSize m_viewportSize;
    110108    WebCore::IntSize m_clientContentsSize;
    111     float m_effectiveScale; // Should always be cssScale * devicePixelRatio.
     109    float m_contentsScale;
    112110
    113111    bool m_pendingPositionChange;

  • trunk/Source/WebKit2/UIProcess/efl/PageViewportControllerClientEfl.cpp

    r137718 r139189  
    6363{
    6464    ASSERT(m_controller);
    65     m_controller->didChangeViewportSize(m_viewImpl->size());
     65    FloatSize size = m_viewImpl->size();
     66    // The viewport controller expects sizes in UI units, and not raw device units.
     67    size.scale(1 / m_controller->devicePixelRatio());
     68    m_controller->didChangeViewportSize(size);
    6669}
    6770

  • trunk/Source/WebKit2/UIProcess/qt/PageViewportControllerClientQt.cpp

    r137149 r139189  
    183183    ASSERT(m_controller->hadUserInteraction());
    184184
    185     const float editingFixedScale = 2 * m_controller->devicePixelRatio();
     185    const float editingFixedScale = 2;
    186186    float targetScale = m_controller->innerBoundedViewportScale(editingFixedScale);
    187187    const QRectF viewportRect = m_viewportItem->boundingRect();
    188188
    189189    qreal x;
    190     const qreal borderOffset = 10 * m_controller->devicePixelRatio();
     190    const qreal borderOffset = 10;
    191191    if ((targetArea.width() + borderOffset) * targetScale <= viewportRect.width()) {
    192192        // Center the input field in the middle of the view, if it is smaller than
    … …  
    222222        return;
    223223
    224     const float margin = 10 * m_controller->devicePixelRatio(); // We want at least a little bit of margin.
     224    const float margin = 10; // We want at least a little bit of margin.
    225225    QRectF endArea = targetArea.adjusted(-margin, -margin, margin, margin);
    226226
    227227    const QRectF viewportRect = m_viewportItem->boundingRect();
    228228
    229     qreal minViewportScale = qreal(2.5) * m_controller->devicePixelRatio();
     229    const qreal minViewportScale = qreal(2.5);
    230230    qreal targetScale = viewportRect.size().width() / endArea.size().width();
    231     targetScale = m_controller->innerBoundedViewportScale(qMin(minViewportScale, targetScale));
     231    targetScale = m_controller->innerBoundedViewportScale(qMax(minViewportScale, targetScale));
    232232    qreal currentScale = m_pageItem->contentsScale();
    233233
    … …  
    269269    case ZoomBack: {
    270270        if (m_scaleStack.isEmpty()) {
    271             targetScale = m_controller->minimumContentsScale() * m_controller->devicePixelRatio();
     271            targetScale = m_controller->minimumContentsScale();
    272272            endPosition.setY(hotspot.y() - viewportHotspot.y() / targetScale);
    273273            endPosition.setX(0);

  • trunk/Source/WebKit2/UIProcess/qt/QtWebPageSGNode.cpp

    r138715 r139189  
    8888        for (const QSGClipNode* clip = clipList(); clip; clip = clip->clipList()) {
    8989            QMatrix4x4 clipMatrix;
    90             if (clip->matrix())
     90            if (pageNode()->devicePixelRatio() != 1.0) {
     91                clipMatrix.scale(pageNode()->devicePixelRatio());
     92                if (clip->matrix())
     93                    clipMatrix *= (*clip->matrix());
     94            } else if (clip->matrix())
    9195                clipMatrix = *clip->matrix();
    92             clipMatrix.scale(pageNode()->devicePixelRatio());
    9396
    9497            QRectF currentClip;

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

    r139050 r139189  
    10321032    Settings* settings = m_page->settings();
    10331033
    1034     int minimumLayoutFallbackWidth = std::max(settings->layoutFallbackWidth(), int(m_viewportSize.width() / m_page->deviceScaleFactor()));
     1034    int minimumLayoutFallbackWidth = std::max(settings->layoutFallbackWidth(), m_viewportSize.width());
    10351035
    10361036    // If unset  we use the viewport dimensions. This fits with the behavior of desktop browsers.
    … …  
    10381038    int deviceHeight = (settings->deviceHeight() > 0) ? settings->deviceHeight() : m_viewportSize.height();
    10391039
    1040     ViewportAttributes attr = computeViewportAttributes(m_page->viewportArguments(), minimumLayoutFallbackWidth, deviceWidth, deviceHeight, m_page->deviceScaleFactor(), m_viewportSize);
     1040    ViewportAttributes attr = computeViewportAttributes(m_page->viewportArguments(), minimumLayoutFallbackWidth, deviceWidth, deviceHeight, 1, m_viewportSize);
    10411041
    10421042    FrameView* view = m_page->mainFrame()->view();
    … …  
    10481048    // Use FloatSize to avoid truncated values during scale.
    10491049    FloatSize contentFixedSize = m_viewportSize;
    1050 
    1051     contentFixedSize.scale(1 / m_page->deviceScaleFactor());
    10521050
    10531051#if ENABLE(CSS_DEVICE_ADAPTATION)
Note: See TracChangeset for help on using the changeset viewer.