ChangeLog

2012-12-11  Andras Becsi  <andras.becsi@digia.com>

        [Qt][WK2] Fix painting on Mac with retina display

        https://bugs.webkit.org/show_bug.cgi?id=104574

        Reviewed by NOBODY (OOPS!).

        Since HiDPI support has been added and enabled in Qt we ended up

        painting incorrectly scaled content on high-resolution screens.

        Because the intrinsic device pixel ratio is always taken into

        account by Qt when painting to high-resolution screens we should

        automatically obtain the scale ratio from the window in which the

        item is rendered instead of setting it in QML.

        Since Qt does not make it possible to override the device pixel ratio

        of the native window our experimental QML API for setting a custom

        value is of no use any more and should be removed.

        This patch fixes the scaling issue on Mac retina display by querying

        the underlying window for the device scale factor, and removes the

        experimental API and related API tests.

        * UIProcess/API/qt/qquickwebpage.cpp:

        (QQuickWebPage::updatePaintNode):

        * UIProcess/API/qt/qquickwebview.cpp:

        (QQuickWebViewPrivate::QQuickWebViewPrivate):

        (QQuickWebViewLegacyPrivate::updateViewportSize):

        (QQuickWebViewFlickablePrivate::onComponentComplete):

        * UIProcess/API/qt/qquickwebview_p.h:

        * UIProcess/API/qt/tests/qmltests/WebView/tst_devicePixelRatio.qml: Removed.

        * UIProcess/API/qt/tests/qquickwebview/tst_qquickwebview.cpp:

        (tst_QQuickWebView::newWebView):

        * UIProcess/PageViewportController.cpp:

        (WebKit::PageViewportController::syncVisibleContents):

        * UIProcess/qt/QtWebPageSGNode.cpp:

        (WebKit::ContentsSGNode::ContentsSGNode):

        (WebKit::ContentsSGNode::render):

        (WebKit::ContentsSGNode::clipRect):

        (ContentsSGNode):

        (WebKit::QtWebPageSGNode::QtWebPageSGNode):

        (WebKit::QtWebPageSGNode::setRenderer):

        * UIProcess/qt/QtWebPageSGNode.h:

        (QtWebPageSGNode):

2012-12-10  Jon Lee  <jonlee@apple.com>

        Keep track of plug-in snapshots clicked by user

Source/WebKit2/UIProcess/API/qt/qquickwebpage.cpp

#include "qquickwebpage_p_p.h"

#include "qquickwebview_p.h"

#include "qwebkittest_p.h"

33#include <QQuickWindow>

using namespace WebKit;

@@QSGNode* QQuickWebPage::updatePaintNode(QSGNode* oldNode, UpdatePaintNodeData*)

    LayerTreeRenderer* renderer = layerTreeCoordinatorProxy->layerTreeRenderer();

    QtWebPageSGNode* node = static_cast<QtWebPageSGNode*>(oldNode);

    QWindow* const w = window();

    ASSERT(w);

    if (d->webPageProxy->deviceScaleFactor() != w->devicePixelRatio()) {

        d->webPageProxy->setIntrinsicDeviceScaleFactor(w->devicePixelRatio());

        d->viewportItem->experimental()->test()->devicePixelRatioChanged();

    }

8796 if (!node)

88 node = new QtWebPageSGNode();

97 node = new QtWebPageSGNode(w);

98

    node->setRenderer(renderer);

    node->setScale(d->contentsScale);

Source/WebKit2/UIProcess/API/qt/qquickwebview.cpp

@@QQuickWebViewPrivate::QQuickWebViewPrivate(QQuickWebView* viewport)

    viewport->setPixelAligned(true);

    QObject::connect(viewport, SIGNAL(visibleChanged()), viewport, SLOT(_q_onVisibleChanged()));

    QObject::connect(viewport, SIGNAL(urlChanged()), viewport, SLOT(_q_onUrlChanged()));

283 QObject::connect(experimental, SIGNAL(devicePixelRatioChanged()), experimental->test(), SIGNAL(devicePixelRatioChanged()));

    pageView.reset(new QQuickWebPage(viewport));

}

@@void QQuickWebViewLegacyPrivate::updateViewportSize()

    float devicePixelRatio = webPageProxy->deviceScaleFactor();

    pageView->setContentsSize(viewportSize);

832 // Make sure that our scale matches the one passed to setVisibleContentsRect.

833 pageView->setContentsScale(devicePixelRatio);

    // The fixed layout is handled by the FrameView and the drawing area doesn't behave differently

    // whether its fixed or not. We still need to tell the drawing area which part of it

    // has to be rendered on tiles, and in desktop mode it's all of it.

838 webPageProxy->drawingArea()->setSize((viewportSize ~~/ devicePixelRatio)~~.toSize(), IntSize());

839 webPageProxy->drawingArea()->setVisibleContentsRect(FloatRect(FloatPoint(), FloatSize(viewportSize ~~/ devicePixelRatio~~)), devicePixelRatio, FloatPoint());

835 webPageProxy->drawingArea()->setSize(viewportSize.toSize(), IntSize());

836 webPageProxy->drawingArea()->setVisibleContentsRect(FloatRect(FloatPoint(), FloatSize(viewportSize)), devicePixelRatio, FloatPoint());

}

qreal QQuickWebViewLegacyPrivate::zoomFactor() const

@@void QQuickWebViewFlickablePrivate::onComponentComplete()

    m_pageViewportController.reset(new PageViewportController(webPageProxy.get(), m_pageViewportControllerClient.data()));

    pageView->eventHandler()->setViewportController(m_pageViewportControllerClient.data());

    // Notify about device pixel ratio here because due to the delayed instantiation

    // of the viewport controller the correct value might not have reached QWebKitTest

    // in time it was used from QML.

    emit experimental->test()->devicePixelRatioChanged();

    // Trigger setting of correct visibility flags after everything was allocated and initialized.

    _q_onVisibleChanged();

}

@@void QQuickWebViewExperimental::setUserAgent(const QString& userAgent)

/*!

    \internal

    \qmlproperty real WebViewExperimental::devicePixelRatio

    \brief The ratio between the CSS units and device pixels when the content is unscaled.

    When designing touch-friendly contents, knowing the approximated target size on a device

    is important for contents providers in order to get the intented layout and element

    sizes.

    As most first generation touch devices had a PPI of approximately 160, this became a

    de-facto value, when used in conjunction with the viewport meta tag.

    Devices with a higher PPI learning towards 240 or 320, applies a pre-scaling on all

    content, of either 1.5 or 2.0, not affecting the CSS scale or pinch zooming.

    This value can be set using this property and it is exposed to CSS media queries using

    the -webkit-device-pixel-ratio query.

    For instance, if you want to load an image without having it upscaled on a web view

    using a device pixel ratio of 2.0 it can be done by loading an image of say 100x100

    pixels but showing it at half the size.

    FIXME: Move documentation example out in separate files

    @media (-webkit-min-device-pixel-ratio: 1.5) {

        .icon {

            width: 50px;

            height: 50px;

            url: "/images/icon@2x.png"; // This is actually a 100x100 image

        }

    }

    If the above is used on a device with device pixel ratio of 1.5, it will be scaled

    down but still provide a better looking image.

*/

qreal QQuickWebViewExperimental::devicePixelRatio() const

{

    Q_D(const QQuickWebView);

    return d->webPageProxy->deviceScaleFactor();

}

void QQuickWebViewExperimental::setDevicePixelRatio(qreal devicePixelRatio)

{

    Q_D(QQuickWebView);

    if (0 >= devicePixelRatio || devicePixelRatio == this->devicePixelRatio())

        return;

    d->webPageProxy->setIntrinsicDeviceScaleFactor(devicePixelRatio);

    emit devicePixelRatioChanged();

}

/*!

    \internal

    \qmlproperty int WebViewExperimental::deviceWidth

    \brief The device width used by the viewport calculations.

Source/WebKit2/UIProcess/API/qt/qquickwebview_p.h

@@class QWEBKIT_EXPORT QQuickWebViewExperimental : public QObject {

    Q_PROPERTY(int preferredMinimumContentsWidth WRITE setPreferredMinimumContentsWidth READ preferredMinimumContentsWidth NOTIFY preferredMinimumContentsWidthChanged)

    Q_PROPERTY(int deviceWidth WRITE setDeviceWidth READ deviceWidth NOTIFY deviceWidthChanged)

    Q_PROPERTY(int deviceHeight WRITE setDeviceHeight READ deviceHeight NOTIFY deviceHeightChanged)

259 Q_PROPERTY(qreal devicePixelRatio READ devicePixelRatio WRITE setDevicePixelRatio NOTIFY devicePixelRatioChanged)

    Q_PROPERTY(QWebNavigationHistory* navigationHistory READ navigationHistory CONSTANT FINAL)

@@public:

    void setDeviceWidth(int);

    int deviceHeight() const;

    void setDeviceHeight(int);

315 qreal devicePixelRatio() const;

316 void setDevicePixelRatio(qreal);

    QList<QUrl> userScripts() const;

    void setUserScripts(const QList<QUrl>& userScripts);

    QUrl remoteInspectorUrl() const;

@@Q_SIGNALS:

    void userAgentChanged();

    void deviceWidthChanged();

    void deviceHeightChanged();

374 void devicePixelRatioChanged();

    void enterFullScreenRequested();

    void exitFullScreenRequested();

    void userScriptsChanged();

Source/WebKit2/UIProcess/API/qt/tests/qmltests/WebView/tst_devicePixelRatio.qml

import QtQuick 2.0

import QtTest 1.0

import QtWebKit 3.0

import QtWebKit.experimental 1.0

import "../common"

TestWebView {

    id: webView

    property variant lastResult

    width: 400

    height: 300

    focus: true

    SignalSpy {

        id: resultSpy

        target: webView

        signalName: "lastResultChanged"

    }

    TestCase {

        name: "DevicePixelRatio"

        function init() {

            resultSpy.clear()

            webView.lastResult = null

        }

        function test_devicePixelRatio() {

            resultSpy.clear()

            webView.url = Qt.resolvedUrl("../common/test1.html");

            webView.experimental.devicePixelRatio = 2.0

            verify(webView.waitForLoadSucceeded())

            webView.experimental.evaluateJavaScript(

                "(function() { return window.devicePixelRatio })()",

                function(result) {

                    webView.lastResult = result

                })

            resultSpy.wait()

            compare(webView.lastResult, 2.0)

            compare(webView.lastResult, webView.experimental.devicePixelRatio)

        }

        function test_devicePixelRatioMediaQuery() {

            resultSpy.clear()

            webView.url = Qt.resolvedUrl("../common/test2.html");

            webView.experimental.devicePixelRatio = 2.0

            verify(webView.waitForLoadSucceeded())

            webView.experimental.evaluateJavaScript(

                "(function() { return window.matchMedia(\"(-webkit-device-pixel-ratio: 2)\").matches })()",

                function(result) {

                    webView.lastResult = result

                })

            resultSpy.wait()

            verify(webView.lastResult)

        }

    }

}

Source/WebKit2/UIProcess/API/qt/tests/qquickwebview/tst_qquickwebview.cpp

@@QQuickWebView* tst_QQuickWebView::newWebView()

{

    QObject* viewInstance = m_component->create();

    QQuickWebView* webView = qobject_cast<QQuickWebView*>(viewInstance);

96 webView->experimental()->setDevicePixelRatio(1.5);

    return webView;

}

Source/WebKit2/UIProcess/PageViewportController.cpp

@@void PageViewportController::syncVisibleContents(const FloatPoint& trajectoryVec

    FloatRect visibleContentsRect(boundContentsPosition(m_contentsPosition), visibleContentsSize());

    visibleContentsRect.intersect(FloatRect(FloatPoint::zero(), m_contentsSize));

264 drawingArea->setVisibleContentsRect(visibleContentsRect, m_effectiveScale, trajectoryVector);

264 drawingArea->setVisibleContentsRect(visibleContentsRect, devicePixelRatio() * m_effectiveScale, trajectoryVector);

    m_client->didChangeVisibleContents();

}

Source/WebKit2/UIProcess/qt/QtWebPageSGNode.cpp

#include "LayerTreeRenderer.h"

#include <QtGui/QPolygonF>

#include <QtQuick/QSGSimpleRectNode>

27#include <WebCore/TransformationMatrix.h>

#include <private/qsgrendernode_p.h>

using namespace WebCore;

@@namespace WebKit {

class ContentsSGNode : public QSGRenderNode {

public:

35 ContentsSGNode(PassRefPtr<LayerTreeRenderer> renderer)

36 ContentsSGNode(PassRefPtr<LayerTreeRenderer> renderer, const QWindow* const parentWindow)

3637 : m_renderer(renderer)

38 , m_window(parentWindow)

    {

        layerTreeRenderer()->setActive(true);

    }

@@public:

    virtual void render(const RenderState& state)

    {

48 QMatrix4x4 renderMatrix = matrix() ? *matrix() : QMatrix4x4();

        ASSERT(m_window);

        TransformationMatrix renderMatrix;

        if (m_window->devicePixelRatio() != 1.0) {

            renderMatrix.scale(m_window->devicePixelRatio());

            if (matrix())

                renderMatrix.multiply(*matrix());

        } else if (matrix())

            renderMatrix = *matrix();

        // When rendering to an intermediate surface, Qt will

        // mirror the projection matrix to fit on the destination coordinate system.

@@public:

private:

    QRectF clipRect() const

    {

78 ASSERT(m_window);

79

        // Start with an invalid rect.

        QRectF resultRect(0, 0, -1, -1);

@@private:

            QMatrix4x4 clipMatrix;

            if (clip->matrix())

                clipMatrix = *clip->matrix();

87 clipMatrix.scale(m_window->devicePixelRatio());

88

            QRectF currentClip;

            if (clip->isRectangular())

@@private:

    }

    RefPtr<LayerTreeRenderer> m_renderer;

122 const QWindow* const m_window;

109123};

110124

111 QtWebPageSGNode::QtWebPageSGNode()

125QtWebPageSGNode::QtWebPageSGNode(const QWindow* const window)

112126 : m_contentsNode(0)

113127 , m_backgroundNode(new QSGSimpleRectNode)

128 , m_window(window)

{

    appendChildNode(m_backgroundNode);

}

@@void QtWebPageSGNode::setRenderer(PassRefPtr<LayerTreeRenderer> renderer)

        return;

    delete m_contentsNode;

137 m_contentsNode = new ContentsSGNode(renderer);

152 m_contentsNode = new ContentsSGNode(renderer, m_window);

    appendChildNode(m_contentsNode);

}

Source/WebKit2/UIProcess/qt/QtWebPageSGNode.h

#ifndef QtWebPageSGNode_h

#define QtWebPageSGNode_h

24#include <QtGui/QWindow>

#include <QtQuick/QSGTransformNode>

#include <wtf/PassRefPtr.h>

@@class LayerTreeRenderer;

class QtWebPageSGNode : public QSGTransformNode {

    public:

38 QtWebPageSGNode();

39 QtWebPageSGNode(const QWindow* const parentWindow);

        void setBackground(const QRectF&, const QColor&);

        void setScale(float);

        void setRenderer(PassRefPtr<LayerTreeRenderer>);

@@class QtWebPageSGNode : public QSGTransformNode {

    private:

        ContentsSGNode* m_contentsNode;

        QSGSimpleRectNode* m_backgroundNode;

47 const QWindow* const m_window;

};

} // namespace WebKit

Tools/ChangeLog

2012-12-11  Andras Becsi  <andras.becsi@digia.com>

        [Qt][WK2] Fix painting on Mac with retina display

        https://bugs.webkit.org/show_bug.cgi?id=104574

        Reviewed by NOBODY (OOPS!).

        Remove setting the devicePixelRatio experimental property

        since the value is now automatically picked up from Qt.

        * MiniBrowser/qt/qml/BrowserWindow.qml:

2012-12-10  Dirk Pranke  <dpranke@chromium.org>

        old-run-webkit-tests: add --show-results properly

Tools/MiniBrowser/qt/qml/BrowserWindow.qml

@@Rectangle {

                webView.loadHtml("Failed to load " + loadRequest.url, "", loadRequest.url)

        }

357 experimental.devicePixelRatio: 1.5

        experimental.preferences.fullScreenEnabled: true

        experimental.preferences.webGLEnabled: true

        experimental.preferences.webAudioEnabled: true