Changeset 141310 in webkit


Ignore:
Timestamp:
Jan 30, 2013 2:27:52 PM (11 years ago)
Author:
commit-queue@webkit.org
Message:

[EFL][Qt][WK2] We should consider a page scale factor in WebCore instead of our own scale factor.
​https://bugs.webkit.org/show_bug.cgi?id=105978

Patch by Huang Dongsung <​luxtella@company100.net> on 2013-01-30
Reviewed by Simon Fraser.

Currently, PageViewportController sends a page scale factor to Coordinated
Graphics System regardless of the page scale factor in WebCore. This patch makes
Coordinated Graphics System use the page scale factor in WebCore to match other
ports.

When it is needed to change a page scale, PageViewportController sends the scale
to Page in Web Process via WebPageProxy::scalePage. When the page scale in
WebCore is changed, CoordinatedGraphicsLayer gets notified via
deviceOrPageScaleFactorChanged callback. CoordinatedGraphicsLayer uses the page
scale factor like previous our own scale factor.

We set true to applyDeviceScaleFactorInCompositor and
ApplyPageScaleFactorInCompositor in Settings like chromium, because
TiledBackingStore that is a backing store of each GraphicsLayer applies the
scale to our raster graphics engines instead of applying the scale to the local
transform of each render object.

Thank Kenneth Rohde Christiansen for implementing the base patch of this patch.

No new tests. Covered by existing tests.

  • UIProcess/API/qt/qquickwebview.cpp:

(QQuickWebViewLegacyPrivate::updateViewportSize):

  • UIProcess/API/qt/raw/qrawwebview.cpp:

(QRawWebView::setSize):

  • UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.cpp:

(WebKit::CoordinatedLayerTreeHostProxy::CoordinatedLayerTreeHostProxy):
(WebKit::CoordinatedLayerTreeHostProxy::setVisibleContentsRect):

Does not receive a pageScaleFactor argument because
PageViewportController sends a page scale factor to Page.
However, this method still receives a scroll position because we
enable delegates scrolling.

  • UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.h:

(CoordinatedLayerTreeHostProxy):

  • UIProcess/DrawingAreaProxy.h:

(WebKit::DrawingAreaProxy::setVisibleContentsRect):

  • UIProcess/DrawingAreaProxyImpl.cpp:

(WebKit::DrawingAreaProxyImpl::setVisibleContentsRect):

  • UIProcess/DrawingAreaProxyImpl.h:
  • UIProcess/PageViewportController.cpp:

(WebKit::PageViewportController::didRenderFrame):
(WebKit::PageViewportController::didChangeContentsVisibility):
(WebKit::PageViewportController::syncVisibleContents):
(WebKit::PageViewportController::applyScaleAfterRenderingContents):
(WebKit::PageViewportController::applyPositionAfterRenderingContents):

  • UIProcess/efl/PageClientLegacyImpl.cpp:

(WebKit::PageClientLegacyImpl::updateViewportSize):

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp:

(WebCore::CoordinatedGraphicsLayer::CoordinatedGraphicsLayer):
(WebCore::CoordinatedGraphicsLayer::deviceOrPageScaleFactorChanged):
(WebCore::CoordinatedGraphicsLayer::effectiveContentsScale):

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h:

(CoordinatedGraphicsLayer):

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp:

(WebKit::CoordinatedLayerTreeHost::CoordinatedLayerTreeHost):
(WebKit::CoordinatedLayerTreeHost::createGraphicsLayer):
(WebKit::CoordinatedLayerTreeHost::deviceScaleFactor):
(WebKit):
(WebKit::CoordinatedLayerTreeHost::pageScaleFactor):
(WebKit::CoordinatedLayerTreeHost::setVisibleContentsRect):
(WebKit::CoordinatedLayerTreeHost::deviceOrPageScaleFactorChanged):

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h:

(CoordinatedLayerTreeHost):

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.messages.in:
  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::setUseFixedLayout):

Location:
trunk/Source/WebKit2
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r141287 r141310  
     12013-01-30  Huang Dongsung  <luxtella@company100.net>
     2
     3        [EFL][Qt][WK2] We should consider a page scale factor in WebCore instead of our own scale factor.
     4        https://bugs.webkit.org/show_bug.cgi?id=105978
     5
     6        Reviewed by Simon Fraser.
     7
     8        Currently, PageViewportController sends a page scale factor to Coordinated
     9        Graphics System regardless of the page scale factor in WebCore. This patch makes
     10        Coordinated Graphics System use the page scale factor in WebCore to match other
     11        ports.
     12
     13        When it is needed to change a page scale, PageViewportController sends the scale
     14        to Page in Web Process via WebPageProxy::scalePage. When the page scale in
     15        WebCore is changed, CoordinatedGraphicsLayer gets notified via
     16        deviceOrPageScaleFactorChanged callback. CoordinatedGraphicsLayer uses the page
     17        scale factor like previous our own scale factor.
     18
     19        We set true to applyDeviceScaleFactorInCompositor and
     20        ApplyPageScaleFactorInCompositor in Settings like chromium, because
     21        TiledBackingStore that is a backing store of each GraphicsLayer applies the
     22        scale to our raster graphics engines instead of applying the scale to the local
     23        transform of each render object.
     24
     25        Thank Kenneth Rohde Christiansen for implementing the base patch of this patch.
     26
     27        No new tests. Covered by existing tests.
     28
     29        * UIProcess/API/qt/qquickwebview.cpp:
     30        (QQuickWebViewLegacyPrivate::updateViewportSize):
     31        * UIProcess/API/qt/raw/qrawwebview.cpp:
     32        (QRawWebView::setSize):
     33        * UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.cpp:
     34        (WebKit::CoordinatedLayerTreeHostProxy::CoordinatedLayerTreeHostProxy):
     35        (WebKit::CoordinatedLayerTreeHostProxy::setVisibleContentsRect):
     36            Does not receive a pageScaleFactor argument because
     37            PageViewportController sends a page scale factor to Page.
     38            However, this method still receives a scroll position because we
     39            enable delegates scrolling.
     40        * UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.h:
     41        (CoordinatedLayerTreeHostProxy):
     42        * UIProcess/DrawingAreaProxy.h:
     43        (WebKit::DrawingAreaProxy::setVisibleContentsRect):
     44        * UIProcess/DrawingAreaProxyImpl.cpp:
     45        (WebKit::DrawingAreaProxyImpl::setVisibleContentsRect):
     46        * UIProcess/DrawingAreaProxyImpl.h:
     47        * UIProcess/PageViewportController.cpp:
     48        (WebKit::PageViewportController::didRenderFrame):
     49        (WebKit::PageViewportController::didChangeContentsVisibility):
     50        (WebKit::PageViewportController::syncVisibleContents):
     51        (WebKit::PageViewportController::applyScaleAfterRenderingContents):
     52        (WebKit::PageViewportController::applyPositionAfterRenderingContents):
     53        * UIProcess/efl/PageClientLegacyImpl.cpp:
     54        (WebKit::PageClientLegacyImpl::updateViewportSize):
     55        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp:
     56        (WebCore::CoordinatedGraphicsLayer::CoordinatedGraphicsLayer):
     57        (WebCore::CoordinatedGraphicsLayer::deviceOrPageScaleFactorChanged):
     58        (WebCore::CoordinatedGraphicsLayer::effectiveContentsScale):
     59        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h:
     60        (CoordinatedGraphicsLayer):
     61        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp:
     62        (WebKit::CoordinatedLayerTreeHost::CoordinatedLayerTreeHost):
     63        (WebKit::CoordinatedLayerTreeHost::createGraphicsLayer):
     64        (WebKit::CoordinatedLayerTreeHost::deviceScaleFactor):
     65        (WebKit):
     66        (WebKit::CoordinatedLayerTreeHost::pageScaleFactor):
     67        (WebKit::CoordinatedLayerTreeHost::setVisibleContentsRect):
     68        (WebKit::CoordinatedLayerTreeHost::deviceOrPageScaleFactorChanged):
     69        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h:
     70        (CoordinatedLayerTreeHost):
     71        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.messages.in:
     72        * WebProcess/WebPage/WebPage.cpp:
     73        (WebKit::WebPage::setUseFixedLayout):
     74
    1752013-01-30  Zoltan Arvai  <zarvai@inf.u-szeged.hu>
    276

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

    r141040 r141310  
    847847    // The backing store scale factor should already be set to the device pixel ratio
    848848    // of the underlying window, thus we set the effective scale to 1 here.
    849     webPageProxy->drawingArea()->setVisibleContentsRect(FloatRect(FloatPoint(), FloatSize(viewportSize)), 1, FloatPoint());
     849    webPageProxy->drawingArea()->setVisibleContentsRect(FloatRect(FloatPoint(), FloatSize(viewportSize)), FloatPoint());
    850850}
    851851

  • trunk/Source/WebKit2/UIProcess/API/qt/raw/qrawwebview.cpp

    r137358 r141310  
    356356
    357357    drawingArea->setSize(d->m_size, WebCore::IntSize());
    358     drawingArea->setVisibleContentsRect(WebCore::IntRect(WebCore::IntPoint(), d->m_size), 1 /*scale*/, WebCore::FloatPoint());
     358    drawingArea->setVisibleContentsRect(WebCore::IntRect(WebCore::IntPoint(), d->m_size), WebCore::FloatPoint());
    359359}
    360360

  • trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.cpp

    r141065 r141310  
    4242    : m_drawingAreaProxy(drawingAreaProxy)
    4343    , m_renderer(adoptRef(new LayerTreeRenderer(this)))
    44     , m_lastSentScale(0)
    4544{
    4645}
    … …  
    5453{
    5554    m_drawingAreaProxy->updateViewport();
    56 }
    57 
    58 float CoordinatedLayerTreeHostProxy::deviceScaleFactor() const
    59 {
    60     return m_drawingAreaProxy->page()->deviceScaleFactor();
    6155}
    6256
    … …  
    186180}
    187181
    188 void CoordinatedLayerTreeHostProxy::setVisibleContentsRect(const FloatRect& rect, float pageScaleFactor, const FloatPoint& trajectoryVector)
     182void CoordinatedLayerTreeHostProxy::setVisibleContentsRect(const FloatRect& rect, const FloatPoint& trajectoryVector)
    189183{
    190184    // Inform the renderer to adjust viewport-fixed layers.
    191185    dispatchUpdate(bind(&LayerTreeRenderer::setVisibleContentsRect, m_renderer.get(), rect));
    192186
    193     const float effectiveScale = deviceScaleFactor() * pageScaleFactor;
    194 
    195     if (rect == m_lastSentVisibleRect && effectiveScale == m_lastSentScale && trajectoryVector == m_lastSentTrajectoryVector)
     187    if (rect == m_lastSentVisibleRect && trajectoryVector == m_lastSentTrajectoryVector)
    196188        return;
    197189
    198     m_drawingAreaProxy->page()->process()->send(Messages::CoordinatedLayerTreeHost::SetVisibleContentsRect(rect, effectiveScale, trajectoryVector), m_drawingAreaProxy->page()->pageID());
     190    m_drawingAreaProxy->page()->process()->send(Messages::CoordinatedLayerTreeHost::SetVisibleContentsRect(rect, trajectoryVector), m_drawingAreaProxy->page()->pageID());
    199191    m_lastSentVisibleRect = rect;
    200     m_lastSentScale = effectiveScale;
    201192    m_lastSentTrajectoryVector = trajectoryVector;
    202193}

  • trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.h

    r141065 r141310  
    6666    void setRootCompositingLayer(CoordinatedLayerID);
    6767    void setContentsSize(const WebCore::FloatSize&);
    68     void setVisibleContentsRect(const WebCore::FloatRect&, float pageScaleFactor, const WebCore::FloatPoint& trajectoryVector);
     68    void setVisibleContentsRect(const WebCore::FloatRect&, const WebCore::FloatPoint& trajectoryVector);
    6969    void didRenderFrame(const WebCore::IntSize& contentsSize, const WebCore::IntRect& coveredRect);
    7070    void createTileForLayer(CoordinatedLayerID, uint32_t tileID, const WebCore::IntRect&, const SurfaceUpdateInfo&);
    … …  
    9797    void setBackgroundColor(const WebCore::Color&);
    9898
    99     float deviceScaleFactor() const;
    100 
    10199protected:
    102100    void dispatchUpdate(const Function<void()>&);
    … …  
    105103    RefPtr<LayerTreeRenderer> m_renderer;
    106104    WebCore::FloatRect m_lastSentVisibleRect;
    107     float m_lastSentScale;
    108105    WebCore::FloatPoint m_lastSentTrajectoryVector;
    109106    typedef HashMap<uint32_t /* atlasID */, RefPtr<CoordinatedSurface> > SurfaceMap;

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

    r137358 r141310  
    8787    virtual WebCore::IntRect contentsRect() const;
    8888    CoordinatedLayerTreeHostProxy* coordinatedLayerTreeHostProxy() const { return m_coordinatedLayerTreeHostProxy.get(); }
    89     virtual void setVisibleContentsRect(const WebCore::FloatRect& /* visibleContentsRect */, float /* scale */, const WebCore::FloatPoint& /* trajectoryVector */) { }
     89    virtual void setVisibleContentsRect(const WebCore::FloatRect& /* visibleContentsRect */, const WebCore::FloatPoint& /* trajectoryVector */) { }
    9090    virtual void didReceiveCoordinatedLayerTreeHostProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&);
    9191

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

    r138973 r141310  
    377377}
    378378
    379 void DrawingAreaProxyImpl::setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, float scale, const WebCore::FloatPoint& trajectoryVector)
     379void DrawingAreaProxyImpl::setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectoryVector)
    380380{
    381381    if (m_coordinatedLayerTreeHostProxy)
    382         m_coordinatedLayerTreeHostProxy->setVisibleContentsRect(visibleContentsRect, scale, trajectoryVector);
     382        m_coordinatedLayerTreeHostProxy->setVisibleContentsRect(visibleContentsRect, trajectoryVector);
    383383}
    384384

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

    r137358 r141310  
    8484    void updateAcceleratedCompositingMode(const LayerTreeContext&);
    8585#if USE(COORDINATED_GRAPHICS)
    86     virtual void setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, float scale, const WebCore::FloatPoint& trajectory);
     86    virtual void setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectory) OVERRIDE;
    8787    void didReceiveCoordinatedLayerTreeHostProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&);
    8888#endif

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

    r139675 r141310  
    198198        FloatPoint pixelAlignedPos = pixelAlignedFloatPoint(currentDiscretePos);
    199199        m_contentsPosition = boundContentsPosition(pixelAlignedPos);
     200
     201        m_webPageProxy->scalePage(m_pageScaleFactor, roundedIntPoint(m_contentsPosition));
    200202    }
    201203
    … …  
    259261        m_contentsPosition = position;
    260262    if (!m_pendingScaleChange)
    261         m_pageScaleFactor = scale;
     263        applyScaleAfterRenderingContents(scale);
    262264
    263265    syncVisibleContents(trajectoryVector);
    … …  
    272274    FloatRect visibleContentsRect(boundContentsPosition(m_contentsPosition), visibleContentsSize());
    273275    visibleContentsRect.intersect(FloatRect(FloatPoint::zero(), m_contentsSize));
    274     drawingArea->setVisibleContentsRect(visibleContentsRect, m_pageScaleFactor, trajectoryVector);
     276    drawingArea->setVisibleContentsRect(visibleContentsRect, trajectoryVector);
    275277
    276278    m_client->didChangeVisibleContents();
    … …  
    327329void PageViewportController::applyScaleAfterRenderingContents(float scale)
    328330{
     331    if (m_pageScaleFactor == scale)
     332        return;
     333
    329334    m_pageScaleFactor = scale;
    330335    m_pendingScaleChange = true;
    … …  
    334339void PageViewportController::applyPositionAfterRenderingContents(const FloatPoint& pos)
    335340{
     341    if (m_contentsPosition == pos)
     342        return;
     343
    336344    m_contentsPosition = pos;
    337345    m_pendingPositionChange = true;

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

    r140686 r141310  
    5151{
    5252#if USE(TILED_BACKING_STORE)
    53     m_view->page()->drawingArea()->setVisibleContentsRect(IntRect(roundedIntPoint(m_view->pagePosition()), m_view->size()), m_view->pageScaleFactor(), FloatPoint());
     53    m_view->page()->drawingArea()->setVisibleContentsRect(IntRect(roundedIntPoint(m_view->pagePosition()), m_view->size()), FloatPoint());
    5454#endif
    5555}

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

    r141247 r141310  
    124124#endif
    125125    , m_coordinator(0)
    126     , m_contentsScale(1)
    127126    , m_compositedNativeImagePtr(0)
    128127    , m_canvasPlatformLayer(0)
    … …  
    699698}
    700699
    701 void CoordinatedGraphicsLayer::setContentsScale(float scale)
    702 {
    703     m_contentsScale = scale;
     700void CoordinatedGraphicsLayer::deviceOrPageScaleFactorChanged()
     701{
    704702    if (shouldHaveBackingStore())
    705703        m_pendingContentsScaleAdjustment = true;
    … …  
    708706float CoordinatedGraphicsLayer::effectiveContentsScale()
    709707{
    710     return selfOrAncestorHaveNonAffineTransforms() ? 1 : m_contentsScale;
     708    return selfOrAncestorHaveNonAffineTransforms() ? 1 : deviceScaleFactor() * pageScaleFactor();
    711709}
    712710

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

    r141247 r141310  
    124124    virtual void setNeedsDisplayInRect(const FloatRect&) OVERRIDE;
    125125    virtual void setContentsNeedsDisplay() OVERRIDE;
     126    virtual void deviceOrPageScaleFactorChanged() OVERRIDE;
    126127    virtual void flushCompositingState(const FloatRect&) OVERRIDE;
    127128    virtual void flushCompositingStateForThisLayerOnly() OVERRIDE;
    … …  
    138139    void computePixelAlignment(FloatPoint& position, FloatSize&, FloatPoint3D& anchorPoint, FloatSize& alignmentOffset);
    139140
    140     void setContentsScale(float);
    141141    void setVisibleContentRectTrajectoryVector(const FloatPoint&);
    142142
    … …  
    253253    OwnPtr<TiledBackingStore> m_mainBackingStore;
    254254    OwnPtr<TiledBackingStore> m_previousBackingStore;
    255     float m_contentsScale;
    256255
    257256    RefPtr<Image> m_compositedImage;

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

    r141065 r141310  
    8888    , m_waitingForUIProcess(true)
    8989    , m_isSuspended(false)
    90     , m_contentsScale(1)
    9190    , m_shouldSendScrollPositionUpdate(true)
    9291    , m_shouldSyncFrame(false)
    … …  
    683682    m_registeredLayers.add(layer);
    684683    m_layersToCreate.append(layer->id());
    685     layer->setContentsScale(m_contentsScale);
    686684    layer->setNeedsVisibleRectAdjustment();
    687685    scheduleLayerFlush();
    688686    return adoptPtr(layer);
     687}
     688
     689float CoordinatedLayerTreeHost::deviceScaleFactor() const
     690{
     691    return m_webPage->deviceScaleFactor();
     692}
     693
     694float CoordinatedLayerTreeHost::pageScaleFactor() const
     695{
     696    return m_webPage->pageScaleFactor();
    689697}
    690698
    … …  
    755763}
    756764
    757 void CoordinatedLayerTreeHost::setVisibleContentsRect(const FloatRect& rect, float scale, const FloatPoint& trajectoryVector)
    758 {
    759     bool contentsRectDidChange = rect != m_visibleContentsRect;
    760     bool contentsScaleDidChange = scale != m_contentsScale;
    761 
     765void CoordinatedLayerTreeHost::setVisibleContentsRect(const FloatRect& rect, const FloatPoint& trajectoryVector)
     766{
    762767    // A zero trajectoryVector indicates that tiles all around the viewport are requested.
    763768    toCoordinatedGraphicsLayer(m_nonCompositedContentLayer.get())->setVisibleContentRectTrajectoryVector(trajectoryVector);
    764769
    765     if (contentsRectDidChange || contentsScaleDidChange) {
     770    bool contentsRectDidChange = rect != m_visibleContentsRect;
     771    if (contentsRectDidChange) {
    766772        m_visibleContentsRect = rect;
    767         m_contentsScale = scale;
    768773
    769774        HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator end = m_registeredLayers.end();
    770775        for (HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it) {
    771             if (contentsScaleDidChange)
    772                 (*it)->setContentsScale(scale);
    773             if (contentsRectDidChange)
    774                 (*it)->setNeedsVisibleRectAdjustment();
     776            (*it)->setNeedsVisibleRectAdjustment();
    775777        }
    776778    }
    … …  
    785787    if (contentsRectDidChange)
    786788        m_shouldSendScrollPositionUpdate = true;
     789}
     790
     791void CoordinatedLayerTreeHost::deviceOrPageScaleFactorChanged()
     792{
     793    m_rootLayer->deviceOrPageScaleFactorChanged();
     794    m_nonCompositedContentLayer->deviceOrPageScaleFactorChanged();
     795    if (m_pageOverlayLayer)
     796        m_pageOverlayLayer->deviceOrPageScaleFactorChanged();
    787797}
    788798

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

    r141171 r141310  
    7777    virtual void pauseRendering() { m_isSuspended = true; }
    7878    virtual void resumeRendering() { m_isSuspended = false; scheduleLayerFlush(); }
    79     virtual void deviceOrPageScaleFactorChanged() { }
     79    virtual void deviceOrPageScaleFactorChanged() OVERRIDE;
    8080    virtual PassRefPtr<CoordinatedImageBacking> createImageBackingIfNeeded(WebCore::Image*) OVERRIDE;
    8181
    … …  
    8787    virtual void renderNextFrame();
    8888    virtual void purgeBackingStores();
    89     virtual void setVisibleContentsRect(const WebCore::FloatRect&, float scale, const WebCore::FloatPoint&);
     89    virtual void setVisibleContentsRect(const WebCore::FloatRect&, const WebCore::FloatPoint&);
    9090    virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&);
    9191    virtual WebCore::GraphicsLayerFactory* graphicsLayerFactory() OVERRIDE;
    … …  
    125125    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    126126    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect);
     127    virtual float deviceScaleFactor() const OVERRIDE;
     128    virtual float pageScaleFactor() const OVERRIDE;
    127129
    128130    // CoordinatedImageBacking::Coordinator
    … …  
    196198    bool m_isSuspended;
    197199    WebCore::FloatRect m_visibleContentsRect;
    198     float m_contentsScale;
    199200    bool m_shouldSendScrollPositionUpdate;
    200201

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

    r140629 r141310  
    2222#if USE(COORDINATED_GRAPHICS)
    2323messages -> CoordinatedLayerTreeHost LegacyReceiver {
    24     SetVisibleContentsRect(WebCore::FloatRect visibleContentsRect, float scale, WebCore::FloatPoint trajectoryVectory)
     24    SetVisibleContentsRect(WebCore::FloatRect visibleContentsRect, WebCore::FloatPoint trajectoryVectory)
    2525    RenderNextFrame()
    2626    PurgeBackingStores()

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

    r141203 r141310  
    12721272    m_page->settings()->setAcceleratedCompositingForFixedPositionEnabled(fixed);
    12731273    m_page->settings()->setFixedPositionCreatesStackingContext(fixed);
     1274    m_page->settings()->setApplyDeviceScaleFactorInCompositor(fixed);
     1275    m_page->settings()->setApplyPageScaleFactorInCompositor(fixed);
    12741276#endif
    12751277
Note: See TracChangeset for help on using the changeset viewer.