Changeset 117535 in webkit


Ignore:
Timestamp:
May 17, 2012 8:36:12 PM (12 years ago)
Author:
danakj@chromium.org
Message:

[chromium] Scale all compositor output by the defaultDeviceScaleFactor
​https://bugs.webkit.org/show_bug.cgi?id=86051

Reviewed by James Robinson.

Source/Platform:

  • chromium/public/WebLayerTreeView.h:

(WebKit::WebLayerTreeView::Settings::Settings):
(Settings):

Source/WebCore:

On initialization, give the defaultDeviceScaleFactor to the compositor
to have it scale all output from WebCore's layout size to physical
pixels. This allows us to scale up to high-dpi devices without using
fixed-layout, so we can leave the WebCore frame size in layout pixels,
while drawing the frame into a larger physical pixel size.

CCLayerTreeHost becomes aware of the deviceScaleFactor and scales all
output by this factor by scaling the viewport and all drawing
transforms.

Anything that works in physical pixels (content space), uses the
deviceViewportSize() in place of the viewportSize(), since when
deviceScaleFactor != 1 in CCLayerTreeHost, the WebCore viewport
is no longer physical pixels.

Scroll positions are in layout pixels, and must be scaled to/from
content space within the compositor.

Unit tests: CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers

  • platform/graphics/chromium/LayerRendererChromium.h:

(LayerRendererChromiumClient):
(WebCore::LayerRendererChromium::viewportSize):
(WebCore::LayerRendererChromium::viewportWidth):
(WebCore::LayerRendererChromium::viewportHeight):
(LayerRendererChromium):

  • platform/graphics/chromium/cc/CCLayerTreeHost.cpp:

(WebCore::CCLayerTreeHost::initializeLayerRenderer):
(WebCore::CCLayerTreeHost::setViewportSize):
(WebCore::CCLayerTreeHost::updateLayers):
(WebCore::CCLayerTreeHost::paintLayerContents):

  • platform/graphics/chromium/cc/CCLayerTreeHost.h:

(WebCore::CCSettings::CCSettings):
(CCSettings):
(CCLayerTreeHost):
(WebCore::CCLayerTreeHost::deviceViewportSize):

  • platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:

(WebCore::CCLayerTreeHostImpl::calculateRenderSurfaceLayerList):
(WebCore::CCLayerTreeHostImpl::calculateRenderPasses):
(WebCore::CCLayerTreeHostImpl::setViewportSize):
(WebCore::CCLayerTreeHostImpl::updateMaxScrollPosition):
(WebCore::CCLayerTreeHostImpl::scrollBegin):
(WebCore::CCLayerTreeHostImpl::computePinchZoomDeltas):

  • platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:

(WebCore::CCLayerTreeHostImpl::viewportSize):
(CCLayerTreeHostImpl):

Source/WebKit/chromium:

Add the applyDefaultDeviceScaleInCompositor setting. When enabled, we
apply the scale factor during compositing instead of applying it through
the pageScaleFactor.

NonCompositedContentHost is the GraphicLayerClient for the GraphicsLayer
containing the document's body. It needs to report the page/device scale
that should be used when scaling the contents of the GraphicsLayer, and
when changes occur to them such that its contentsSize or contentsScale
is affected.

Store the deviceScaleFactor being used in the compositor. The remainder
of the deviceScaleFactor() is being applied to the pageScale.

  • public/WebSettings.h:
  • src/NonCompositedContentHost.cpp:

(WebKit::NonCompositedContentHost::NonCompositedContentHost):
(WebKit::NonCompositedContentHost::setViewport):

  • src/NonCompositedContentHost.h:

(NonCompositedContentHost):

  • src/WebLayerTreeView.cpp:

(WebKit::WebLayerTreeView::Settings::operator CCSettings):

  • src/WebSettingsImpl.cpp:

(WebKit::WebSettingsImpl::setApplyDefaultDeviceScaleFactorInCompositor):
(WebKit):

  • src/WebSettingsImpl.h:

(WebSettingsImpl):
(WebKit::WebSettingsImpl::applyDefaultDeviceScaleFactorInCompositor):

  • src/WebViewImpl.cpp:

(WebKit::WebViewImpl::WebViewImpl):
(WebKit::WebViewImpl::setPageScaleFactor):
(WebKit::WebViewImpl::setDeviceScaleFactor):
(WebKit::WebViewImpl::enableFixedLayoutMode):
(WebKit::WebViewImpl::computePageScaleFactorLimits):
(WebKit::WebViewImpl::setIsAcceleratedCompositingActive):
(WebKit::WebViewImpl::updateLayerTreeViewport):

  • src/WebViewImpl.h:
  • tests/CCLayerTreeHostTest.cpp:

(MockLayerTreeHostImpl):
(WTF::MockLayerTreeHost::createLayerTreeHostImpl):
(CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers):
(WTF::CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers::CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers):
(WTF::CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers::beginTest):
(WTF::CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers::commitCompleteOnCCThread):
(WTF::CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers::afterTest):
(WTF):
(WTF::TEST_F):

  • tests/LayerRendererChromiumTest.cpp:
  • tests/WebFrameTest.cpp:

(WebKit::TEST_F):

Location:
trunk/Source
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/Platform/ChangeLog

    r117529 r117535  
     12012-05-17  Dana Jansens  <danakj@chromium.org>
     2
     3        [chromium] Scale all compositor output by the defaultDeviceScaleFactor
     4        https://bugs.webkit.org/show_bug.cgi?id=86051
     5
     6        Reviewed by James Robinson.
     7
     8        * chromium/public/WebLayerTreeView.h:
     9        (WebKit::WebLayerTreeView::Settings::Settings):
     10        (Settings):
     11
    1122012-05-17  Ami Fischman  <fischman@chromium.org>
    213

  • trunk/Source/Platform/chromium/public/WebLayerTreeView.h

    r117521 r117535  
    6060            , defaultTileSize(WebSize(256, 256))
    6161            , maxUntiledLayerSize(WebSize(512, 512))
     62            , deviceScaleFactor(1)
    6263        {
    6364        }
    … …  
    7374        WebSize defaultTileSize;
    7475        WebSize maxUntiledLayerSize;
     76        float deviceScaleFactor;
    7577#if WEBKIT_IMPLEMENTATION
    7678        operator WebCore::CCSettings() const;

  • trunk/Source/WebCore/ChangeLog

    r117534 r117535  
     12012-05-17  Dana Jansens  <danakj@chromium.org>
     2
     3        [chromium] Scale all compositor output by the defaultDeviceScaleFactor
     4        https://bugs.webkit.org/show_bug.cgi?id=86051
     5
     6        Reviewed by James Robinson.
     7
     8        On initialization, give the defaultDeviceScaleFactor to the compositor
     9        to have it scale all output from WebCore's layout size to physical
     10        pixels. This allows us to scale up to high-dpi devices without using
     11        fixed-layout, so we can leave the WebCore frame size in layout pixels,
     12        while drawing the frame into a larger physical pixel size.
     13
     14        CCLayerTreeHost becomes aware of the deviceScaleFactor and scales all
     15        output by this factor by scaling the viewport and all drawing
     16        transforms.
     17
     18        Anything that works in physical pixels (content space), uses the
     19        deviceViewportSize() in place of the viewportSize(), since when
     20        deviceScaleFactor != 1 in CCLayerTreeHost, the WebCore viewport
     21        is no longer physical pixels.
     22
     23        Scroll positions are in layout pixels, and must be scaled to/from
     24        content space within the compositor.
     25
     26        Unit tests: CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
     27
     28        * platform/graphics/chromium/LayerRendererChromium.h:
     29        (LayerRendererChromiumClient):
     30        (WebCore::LayerRendererChromium::viewportSize):
     31        (WebCore::LayerRendererChromium::viewportWidth):
     32        (WebCore::LayerRendererChromium::viewportHeight):
     33        (LayerRendererChromium):
     34        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
     35        (WebCore::CCLayerTreeHost::initializeLayerRenderer):
     36        (WebCore::CCLayerTreeHost::setViewportSize):
     37        (WebCore::CCLayerTreeHost::updateLayers):
     38        (WebCore::CCLayerTreeHost::paintLayerContents):
     39        * platform/graphics/chromium/cc/CCLayerTreeHost.h:
     40        (WebCore::CCSettings::CCSettings):
     41        (CCSettings):
     42        (CCLayerTreeHost):
     43        (WebCore::CCLayerTreeHost::deviceViewportSize):
     44        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
     45        (WebCore::CCLayerTreeHostImpl::calculateRenderSurfaceLayerList):
     46        (WebCore::CCLayerTreeHostImpl::calculateRenderPasses):
     47        (WebCore::CCLayerTreeHostImpl::setViewportSize):
     48        (WebCore::CCLayerTreeHostImpl::updateMaxScrollPosition):
     49        (WebCore::CCLayerTreeHostImpl::scrollBegin):
     50        (WebCore::CCLayerTreeHostImpl::computePinchZoomDeltas):
     51        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:
     52        (WebCore::CCLayerTreeHostImpl::viewportSize):
     53        (CCLayerTreeHostImpl):
     54
    1552012-05-17  Hayato Ito  <hayato@chromium.org>
    256

  • trunk/Source/WebCore/platform/graphics/chromium/LayerRendererChromium.h

    r116779 r117535  
    6767class LayerRendererChromiumClient {
    6868public:
    69     virtual const IntSize& viewportSize() const = 0;
     69    virtual const IntSize& deviceViewportSize() const = 0;
    7070    virtual const CCSettings& settings() const = 0;
    7171    virtual void didLoseContext() = 0;
    … …  
    9191    bool contextSupportsMapSub() const { return m_capabilities.usingMapSub; }
    9292
    93     const IntSize& viewportSize() { return m_client->viewportSize(); }
    94     int viewportWidth() { return viewportSize().width(); }
    95     int viewportHeight() { return viewportSize().height(); }
    96 
    9793    void viewportChanged();
    9894
    … …  
    151147
    152148private:
     149    const IntSize& viewportSize() { return m_client->deviceViewportSize(); }
     150    int viewportWidth() { return viewportSize().width(); }
     151    int viewportHeight() { return viewportSize().height(); }
     152
    153153    void drawQuad(const CCDrawQuad*, const FloatRect& surfaceDamageRect);
    154154    void drawCheckerboardQuad(const CCCheckerboardDrawQuad*);

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp

    r117521 r117535  
    144144    m_settings.maxPartialTextureUpdates = min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates());
    145145
    146     m_contentsTextureManager = TextureManager::create(TextureManager::highLimitBytes(viewportSize()),
    147                                                       TextureManager::reclaimLimitBytes(viewportSize()),
     146    m_contentsTextureManager = TextureManager::create(TextureManager::highLimitBytes(deviceViewportSize()),
     147                                                      TextureManager::reclaimLimitBytes(deviceViewportSize()),
    148148                                                      m_proxy->layerRendererCapabilities().maxTextureSize);
    149149
    … …  
    368368
    369369    m_viewportSize = viewportSize;
     370
     371    m_deviceViewportSize = viewportSize;
     372    m_deviceViewportSize.scale(m_settings.deviceScaleFactor);
     373
    370374    setNeedsCommit();
    371375}
    … …  
    484488    if (!rootLayer->renderSurface())
    485489        rootLayer->createRenderSurface();
    486     rootLayer->renderSurface()->setContentRect(IntRect(IntPoint(0, 0), viewportSize()));
    487 
    488     IntRect rootClipRect(IntPoint(), viewportSize());
     490    rootLayer->renderSurface()->setContentRect(IntRect(IntPoint(0, 0), deviceViewportSize()));
     491
     492    IntRect rootClipRect(IntPoint(), deviceViewportSize());
    489493    rootLayer->setClipRect(rootClipRect);
    490494
    … …  
    495499    rootRenderSurface->clearLayerList();
    496500
    497     TransformationMatrix identityMatrix;
    498501    {
    499502        TRACE_EVENT("CCLayerTreeHost::updateLayers::calcDrawEtc", this, 0);
    500         CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootLayer, rootLayer, identityMatrix, identityMatrix, updateList, rootRenderSurface->layerList(), layerRendererCapabilities().maxTextureSize);
     503        TransformationMatrix identityMatrix;
     504        TransformationMatrix deviceScaleTransform;
     505        deviceScaleTransform.scale(m_settings.deviceScaleFactor);
     506        CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, updateList, rootRenderSurface->layerList(), layerRendererCapabilities().maxTextureSize);
    501507    }
    502508
    … …  
    576582
    577583    bool recordMetricsForFrame = true; // FIXME: In the future, disable this when about:tracing is off.
    578     CCOcclusionTracker occlusionTracker(IntRect(IntPoint(), viewportSize()), recordMetricsForFrame);
     584    CCOcclusionTracker occlusionTracker(IntRect(IntPoint(), deviceViewportSize()), recordMetricsForFrame);
    579585    occlusionTracker.setMinimumTrackingSize(CCOcclusionTracker::preferredMinimumTrackingSize());
    580586

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h

    r117521 r117535  
    8686            , maxPartialTextureUpdates(std::numeric_limits<size_t>::max())
    8787            , defaultTileSize(IntSize(256, 256))
    88             , maxUntiledLayerSize(IntSize(512, 512)) { }
     88            , maxUntiledLayerSize(IntSize(512, 512))
     89            , deviceScaleFactor(1)
     90    { }
    8991
    9092    bool acceleratePainting;
    … …  
    101103    IntSize defaultTileSize;
    102104    IntSize maxUntiledLayerSize;
     105    float deviceScaleFactor;
    103106};
    104107
    … …  
    214217
    215218    const IntSize& viewportSize() const { return m_viewportSize; }
     219    // Gives the viewport size in device/content space.
     220    const IntSize& deviceViewportSize() const { return m_deviceViewportSize; }
    216221
    217222    void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor);
    … …  
    282287
    283288    IntSize m_viewportSize;
     289    IntSize m_deviceViewportSize;
    284290    bool m_visible;
    285291    typedef HashMap<GraphicsContext3D*, RefPtr<RateLimiter> > RateLimiterMap;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp

    r117171 r117535  
    252252        m_rootLayerImpl->createRenderSurface();
    253253    m_rootLayerImpl->renderSurface()->clearLayerList();
    254     m_rootLayerImpl->renderSurface()->setContentRect(IntRect(IntPoint(), viewportSize()));
    255 
    256     m_rootLayerImpl->setClipRect(IntRect(IntPoint(), viewportSize()));
     254    m_rootLayerImpl->renderSurface()->setContentRect(IntRect(IntPoint(), deviceViewportSize()));
     255
     256    m_rootLayerImpl->setClipRect(IntRect(IntPoint(), deviceViewportSize()));
    257257
    258258    {
     259        TRACE_EVENT("CCLayerTreeHostImpl::calcDrawEtc", this, 0);
    259260        TransformationMatrix identityMatrix;
    260         TRACE_EVENT("CCLayerTreeHostImpl::calcDrawEtc", this, 0);
    261         CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(m_rootLayerImpl.get(), m_rootLayerImpl.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, m_rootLayerImpl->renderSurface()->layerList(), &m_layerSorter, layerRendererCapabilities().maxTextureSize);
     261        TransformationMatrix deviceScaleTransform;
     262        deviceScaleTransform.scale(m_settings.deviceScaleFactor);
     263        CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(m_rootLayerImpl.get(), m_rootLayerImpl.get(), deviceScaleTransform, identityMatrix, renderSurfaceLayerList, m_rootLayerImpl->renderSurface()->layerList(), &m_layerSorter, layerRendererCapabilities().maxTextureSize);
    262264    }
    263265}
    … …  
    296298        scissorRect = enclosingIntRect(m_rootDamageRect);
    297299    else
    298         scissorRect = IntRect(IntPoint(), viewportSize());
     300        scissorRect = IntRect(IntPoint(), deviceViewportSize());
    299301
    300302    bool recordMetricsForFrame = true; // FIXME: In the future, disable this when about:tracing is off.
    … …  
    553555
    554556    m_viewportSize = viewportSize;
     557
     558    m_deviceViewportSize = viewportSize;
     559    m_deviceViewportSize.scale(m_settings.deviceScaleFactor);
     560
    555561    updateMaxScrollPosition();
    556562
    … …  
    629635    }
    630636    viewBounds.scale(1 / m_pageScaleDelta);
    631 
     637    viewBounds.scale(m_settings.deviceScaleFactor);
     638
     639    // maxScroll is computed in physical pixels, but scroll positions are in layout pixels.
    632640    IntSize maxScroll = contentSize() - expandedIntSize(viewBounds);
     641    maxScroll.scale(1 / m_settings.deviceScaleFactor);
    633642    // The viewport may be larger than the contents in some cases, such as
    634643    // having a vertical scrollbar but no horizontal overflow.
    … …  
    658667    }
    659668
    660     IntPoint scrollLayerContentPoint(m_scrollLayerImpl->screenSpaceTransform().inverse().mapPoint(viewportPoint));
    661     if (m_scrollLayerImpl->nonFastScrollableRegion().contains(scrollLayerContentPoint)) {
     669    IntPoint deviceViewportPoint = viewportPoint;
     670    deviceViewportPoint.scale(m_settings.deviceScaleFactor, m_settings.deviceScaleFactor);
     671
     672    // The inverse of the screen space transform takes us from physical pixels to layout pixels.
     673    IntPoint scrollLayerPoint(m_scrollLayerImpl->screenSpaceTransform().inverse().mapPoint(deviceViewportPoint));
     674
     675    if (m_scrollLayerImpl->nonFastScrollableRegion().contains(scrollLayerPoint)) {
    662676        TRACE_EVENT("scrollBegin Failed nonFastScrollableRegion", this, 0);
    663677        return ScrollFailed;
    … …  
    758772    scrollEnd.scale(m_minPageScale / scaleBegin);
    759773    scrollEnd -= anchor;
    760     scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_viewportSize)).expandedTo(FloatSize(0, 0));
     774    scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceViewportSize)).expandedTo(FloatSize(0, 0));
    761775    scrollEnd.scale(1 / pageScaleDeltaToSend);
     776    scrollEnd.scale(m_settings.deviceScaleFactor);
    762777
    763778    makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScale);

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h

    r116779 r117535  
    106106
    107107    // LayerRendererChromiumClient implementation
    108     virtual const IntSize& viewportSize() const OVERRIDE { return m_viewportSize; }
     108    virtual const IntSize& deviceViewportSize() const OVERRIDE { return m_deviceViewportSize; }
    109109    virtual const CCSettings& settings() const OVERRIDE { return m_settings; }
    110110    virtual void didLoseContext() OVERRIDE;
    … …  
    145145    void setSourceFrameNumber(int frameNumber) { m_sourceFrameNumber = frameNumber; }
    146146
     147    const IntSize& viewportSize() const { return m_viewportSize; }
    147148    void setViewportSize(const IntSize&);
    148149
     150    float pageScale() const { return m_pageScale; }
    149151    void setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale);
    150     float pageScale() const { return m_pageScale; }
    151152
    152153    PassOwnPtr<CCScrollAndScaleSet> processScrollDeltas();
    … …  
    170171    void animatePageScale(double monotonicTime);
    171172    void animateGestures(double monotonicTime);
     173
     174    // Exposed for testing.
     175    void calculateRenderSurfaceLayerList(CCLayerList&);
    172176
    173177    // Virtual for testing.
    … …  
    188192    void updateMaxScrollPosition();
    189193    void trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList);
    190     void calculateRenderSurfaceLayerList(CCLayerList&);
    191194
    192195    // Returns false if the frame should not be displayed. This function should
    … …  
    206209    CCSettings m_settings;
    207210    IntSize m_viewportSize;
     211    IntSize m_deviceViewportSize;
    208212    bool m_visible;
    209213

  • trunk/Source/WebKit/chromium/ChangeLog

    r117521 r117535  
     12012-05-17  Dana Jansens  <danakj@chromium.org>
     2
     3        [chromium] Scale all compositor output by the defaultDeviceScaleFactor
     4        https://bugs.webkit.org/show_bug.cgi?id=86051
     5
     6        Reviewed by James Robinson.
     7
     8        Add the applyDefaultDeviceScaleInCompositor setting. When enabled, we
     9        apply the scale factor during compositing instead of applying it through
     10        the pageScaleFactor.
     11
     12        NonCompositedContentHost is the GraphicLayerClient for the GraphicsLayer
     13        containing the document's body. It needs to report the page/device scale
     14        that should be used when scaling the contents of the GraphicsLayer, and
     15        when changes occur to them such that its contentsSize or contentsScale
     16        is affected.
     17
     18        Store the deviceScaleFactor being used in the compositor. The remainder
     19        of the deviceScaleFactor() is being applied to the pageScale.
     20
     21        * public/WebSettings.h:
     22        * src/NonCompositedContentHost.cpp:
     23        (WebKit::NonCompositedContentHost::NonCompositedContentHost):
     24        (WebKit::NonCompositedContentHost::setViewport):
     25        * src/NonCompositedContentHost.h:
     26        (NonCompositedContentHost):
     27        * src/WebLayerTreeView.cpp:
     28        (WebKit::WebLayerTreeView::Settings::operator CCSettings):
     29        * src/WebSettingsImpl.cpp:
     30        (WebKit::WebSettingsImpl::setApplyDefaultDeviceScaleFactorInCompositor):
     31        (WebKit):
     32        * src/WebSettingsImpl.h:
     33        (WebSettingsImpl):
     34        (WebKit::WebSettingsImpl::applyDefaultDeviceScaleFactorInCompositor):
     35        * src/WebViewImpl.cpp:
     36        (WebKit::WebViewImpl::WebViewImpl):
     37        (WebKit::WebViewImpl::setPageScaleFactor):
     38        (WebKit::WebViewImpl::setDeviceScaleFactor):
     39        (WebKit::WebViewImpl::enableFixedLayoutMode):
     40        (WebKit::WebViewImpl::computePageScaleFactorLimits):
     41        (WebKit::WebViewImpl::setIsAcceleratedCompositingActive):
     42        (WebKit::WebViewImpl::updateLayerTreeViewport):
     43        * src/WebViewImpl.h:
     44        * tests/CCLayerTreeHostTest.cpp:
     45        (MockLayerTreeHostImpl):
     46        (WTF::MockLayerTreeHost::createLayerTreeHostImpl):
     47        (CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers):
     48        (WTF::CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers::CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers):
     49        (WTF::CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers::beginTest):
     50        (WTF::CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers::commitCompleteOnCCThread):
     51        (WTF::CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers::afterTest):
     52        (WTF):
     53        (WTF::TEST_F):
     54        * tests/LayerRendererChromiumTest.cpp:
     55        * tests/WebFrameTest.cpp:
     56        (WebKit::TEST_F):
     57
    1582012-05-17  Vangelis Kokkevis  <vangelis@chromium.org>
    259

  • trunk/Source/WebKit/chromium/public/WebSettings.h

    r117521 r117535  
    6565    virtual void setMinimumLogicalFontSize(int) = 0;
    6666    virtual void setDefaultDeviceScaleFactor(int) = 0;
     67    virtual void setApplyDefaultDeviceScaleFactorInCompositor(bool) = 0;
    6768    virtual void setDefaultTextEncodingName(const WebString&) = 0;
    6869    virtual void setJavaScriptEnabled(bool) = 0;

  • trunk/Source/WebKit/chromium/src/NonCompositedContentHost.cpp

    r113871 r117535  
    4040    : m_contentPaint(contentPaint)
    4141    , m_showDebugBorders(false)
     42    , m_deviceScaleFactor(1.0)
    4243{
    4344    m_graphicsLayer = WebCore::GraphicsLayer::create(this);
    … …  
    9394}
    9495
    95 void NonCompositedContentHost::setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, float pageScale, int layerAdjustX)
     96void NonCompositedContentHost::setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, float deviceScale, int layerAdjustX)
    9697{
    9798    if (!scrollLayer())
    … …  
    106107    // assumed to be scrollable.
    107108    scrollLayer()->setScrollable(true);
     109    m_deviceScaleFactor = deviceScale;
     110    m_graphicsLayer->deviceOrPageScaleFactorChanged();
    108111    m_graphicsLayer->setSize(contentsSize);
    109112
    … …  
    119122    } else if (visibleRectChanged)
    120123        m_graphicsLayer->setNeedsDisplay();
    121 
    122     if (m_graphicsLayer->pageScaleFactor() != pageScale)
    123         m_graphicsLayer->deviceOrPageScaleFactorChanged();
    124124
    125125    WebCore::LayerChromium* clipLayer = scrollLayer()->parent();

  • trunk/Source/WebKit/chromium/src/NonCompositedContentHost.h

    r105757 r117535  
    5858    void setBackgroundColor(const WebCore::Color&);
    5959    void setScrollLayer(WebCore::GraphicsLayer*);
    60     void setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, float pageScale, int layerAdjustX);
     60    void setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, float deviceScale, int layerAdjustX);
    6161    void protectVisibleTileTextures();
    6262    WebCore::GraphicsLayer* topLevelRootLayer() const { return m_graphicsLayer.get(); }
    … …  
    7474    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;
    7575    virtual bool showRepaintCounter(const WebCore::GraphicsLayer*) const;
     76    // The deviceScaleFactor given to the GraphicsLayer can be non-1 when the
     77    // contents are scaled in the compositor instead of by the pageScaleFactor.
     78    // However, the pageScaleFactor is always baked into the GraphicsLayer's
     79    // size, so it is always 1 for the GraphicsLayer.
     80    virtual float deviceScaleFactor() const OVERRIDE { return m_deviceScaleFactor; }
    7681
    7782    WebCore::LayerChromium* scrollLayer();
    … …  
    8287    int m_layerAdjustX;
    8388    bool m_showDebugBorders;
     89    float m_deviceScaleFactor;
    8490};
    8591

  • trunk/Source/WebKit/chromium/src/WebLayerTreeView.cpp

    r117521 r117535  
    5151    settings.defaultTileSize = defaultTileSize;
    5252    settings.maxUntiledLayerSize = maxUntiledLayerSize;
     53    settings.deviceScaleFactor = deviceScaleFactor;
    5354
    5455    // FIXME: showFPSCounter / showPlatformLayerTree / maxPartialTextureUpdates aren't supported currently.

  • trunk/Source/WebKit/chromium/src/WebSettingsImpl.cpp

    r117521 r117535  
    5252    , m_showPaintRects(false)
    5353    , m_viewportEnabled(false)
     54    , m_applyDefaultDeviceScaleFactorInCompositor(false)
    5455    , m_defaultTileSize(WebSize(256, 256))
    5556    , m_maxUntiledLayerSize(WebSize(512, 512))
    … …  
    118119}
    119120
     121void WebSettingsImpl::setApplyDefaultDeviceScaleFactorInCompositor(bool applyDefaultDeviceScaleFactorInCompositor)
     122{
     123    m_applyDefaultDeviceScaleFactorInCompositor = applyDefaultDeviceScaleFactorInCompositor;
     124}
     125
    120126void WebSettingsImpl::setDefaultTextEncodingName(const WebString& encoding)
    121127{

  • trunk/Source/WebKit/chromium/src/WebSettingsImpl.h

    r117521 r117535  
    5656    virtual void setMinimumLogicalFontSize(int);
    5757    virtual void setDefaultDeviceScaleFactor(int);
     58    virtual void setApplyDefaultDeviceScaleFactorInCompositor(bool);
    5859    virtual void setDefaultTextEncodingName(const WebString&);
    5960    virtual void setJavaScriptEnabled(bool);
    … …  
    147148    bool showPlatformLayerTree() const { return m_showPlatformLayerTree; }
    148149    bool showPaintRects() const { return m_showPaintRects; }
     150    bool applyDefaultDeviceScaleFactorInCompositor() const { return m_applyDefaultDeviceScaleFactorInCompositor; }
    149151    WebSize defaultTileSize() const { return m_defaultTileSize; }
    150152    WebSize maxUntiledLayerSize() const { return m_maxUntiledLayerSize; }
    … …  
    156158    bool m_showPaintRects;
    157159    bool m_viewportEnabled;
     160    bool m_applyDefaultDeviceScaleFactorInCompositor;
    158161    WebSize m_defaultTileSize;
    159162    WebSize m_maxUntiledLayerSize;

  • trunk/Source/WebKit/chromium/src/WebViewImpl.cpp

    r117521 r117535  
    397397    , m_recreatingGraphicsContext(false)
    398398    , m_compositorSurfaceReady(false)
     399    , m_deviceScaleInCompositor(1)
    399400#endif
    400401#if ENABLE(INPUT_SPEECH)
    … …  
    23622363        scaleFactor = 1;
    23632364
     2365    if (m_deviceScaleInCompositor != 1) {
     2366        // Don't allow page scaling when compositor scaling is being used,
     2367        // as they are currently incompatible.
     2368        ASSERT(scaleFactor == 1);
     2369    }
     2370
    23642371    scaleFactor = clampPageScaleFactorToLimits(scaleFactor);
    23652372    WebPoint clampedOrigin = clampOffsetAtScale(origin, scaleFactor);
    … …  
    23822389
    23832390    page()->setDeviceScaleFactor(scaleFactor);
     2391
     2392    if (m_deviceScaleInCompositor != 1) {
     2393        // Don't allow page scaling when compositor scaling is being used,
     2394        // as they are currently incompatible. This means the deviceScale
     2395        // needs to match the one in the compositor.
     2396        ASSERT(scaleFactor == m_deviceScaleInCompositor);
     2397    }
    23842398}
    23852399
    … …  
    24092423#if USE(ACCELERATED_COMPOSITING)
    24102424    // Also notify the base layer, which RenderLayerCompositor does not see.
    2411     if (m_nonCompositedContentHost) {
    2412         m_nonCompositedContentHost->topLevelRootLayer()->deviceOrPageScaleFactorChanged();
     2425    if (m_nonCompositedContentHost)
    24132426        updateLayerTreeViewport();
    2414     }
    24152427#endif
    24162428}
    … …  
    24462458        return false;
    24472459
    2448     m_minimumPageScaleFactor = min(max(m_pageDefinedMinimumPageScaleFactor, minPageScaleFactor), maxPageScaleFactor) * deviceScaleFactor();
    2449     m_maximumPageScaleFactor = max(min(m_pageDefinedMaximumPageScaleFactor, maxPageScaleFactor), minPageScaleFactor) * deviceScaleFactor();
     2460    m_minimumPageScaleFactor = min(max(m_pageDefinedMinimumPageScaleFactor, minPageScaleFactor), maxPageScaleFactor) * (deviceScaleFactor() / m_deviceScaleInCompositor);
     2461    m_maximumPageScaleFactor = max(min(m_pageDefinedMaximumPageScaleFactor, maxPageScaleFactor), minPageScaleFactor) * (deviceScaleFactor() / m_deviceScaleInCompositor);
    24502462
    24512463    int viewWidthNotIncludingScrollbars = page()->mainFrame()->view()->visibleContentRect(false).width();
    … …  
    33963408        m_nonCompositedContentHost->setShowDebugBorders(page()->settings()->showDebugBorders());
    33973409
     3410        if (m_webSettings->applyDefaultDeviceScaleFactorInCompositor() && page()->settings()->defaultDeviceScaleFactor() != 1) {
     3411            ASSERT(page()->settings()->defaultDeviceScaleFactor());
     3412
     3413            m_deviceScaleInCompositor = page()->settings()->defaultDeviceScaleFactor();
     3414            layerTreeViewSettings.deviceScaleFactor = m_deviceScaleInCompositor;
     3415            setDeviceScaleFactor(m_deviceScaleInCompositor);
     3416            // When applying a scale factor in the compositor, we disallow page
     3417            // scaling as they are currently incompatible.
     3418            setPageScaleFactorLimits(1, 1);
     3419        }
     3420
    33983421        m_layerTreeView.initialize(this, m_rootLayer, layerTreeViewSettings);
    33993422        if (!m_layerTreeView.isNull()) {
    … …  
    35393562        layerAdjustX = -view->contentsSize().width() + view->visibleContentRect(false).width();
    35403563    }
    3541     m_nonCompositedContentHost->setViewport(visibleRect.size(), view->contentsSize(), scroll, pageScaleFactor(), layerAdjustX);
     3564
     3565    // This part of the deviceScale will be used to scale the contents of
     3566    // the NCCH's GraphicsLayer.
     3567    float deviceScale = m_deviceScaleInCompositor;
     3568    m_nonCompositedContentHost->setViewport(visibleRect.size(), view->contentsSize(), scroll, deviceScale, layerAdjustX);
     3569
    35423570    m_layerTreeView.setViewportSize(size());
    35433571    m_layerTreeView.setPageScaleFactorAndLimits(pageScaleFactor(), m_minimumPageScaleFactor, m_maximumPageScaleFactor);

  • trunk/Source/WebKit/chromium/src/WebViewImpl.h

    r117460 r117535  
    779779    bool m_recreatingGraphicsContext;
    780780    bool m_compositorSurfaceReady;
     781    float m_deviceScaleInCompositor;
    781782#endif
    782783    static const WebInputEvent* m_currentInputEvent;

  • trunk/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp

    r117171 r117535  
    5959using namespace WTF;
    6060
     61#define EXPECT_EQ_RECT(a, b) \
     62    EXPECT_EQ(a.x(), b.x()); \
     63    EXPECT_EQ(a.y(), b.y()); \
     64    EXPECT_EQ(a.width(), b.width()); \
     65    EXPECT_EQ(a.height(), b.height());
     66
    6167namespace {
    6268
    … …  
    114120    }
    115121
     122    // Make these public.
     123    typedef Vector<CCLayerImpl*> CCLayerList;
     124    using CCLayerTreeHostImpl::calculateRenderSurfaceLayerList;
     125
    116126protected:
    117127    virtual void animateLayers(double monotonicTime, double wallClockTime)
    … …  
    157167    {
    158168        // For these tests, we will enable threaded animations.
    159         CCSettings settings;
    160         settings.threadedAnimationEnabled = true;
    161         return MockLayerTreeHostImpl::create(m_testHooks, settings, client);
     169        CCSettings copySettings = settings();
     170        copySettings.threadedAnimationEnabled = true;
     171        return MockLayerTreeHostImpl::create(m_testHooks, copySettings, client);
    162172    }
    163173
    … …  
    17441754    void notifySyncRequired() { }
    17451755};
     1756
     1757class CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers : public CCLayerTreeHostTest {
     1758public:
     1759
     1760    CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers()
     1761        : m_rootLayer(ContentLayerChromium::create(&m_delegate))
     1762        , m_childLayer(ContentLayerChromium::create(&m_delegate))
     1763    {
     1764        m_settings.deviceScaleFactor = 1.5;
     1765    }
     1766
     1767    virtual void beginTest()
     1768    {
     1769        // The device viewport should be scaled by the device scale factor.
     1770        m_layerTreeHost->setViewportSize(IntSize(40, 40));
     1771        EXPECT_EQ(IntSize(40, 40), m_layerTreeHost->viewportSize());
     1772        EXPECT_EQ(IntSize(60, 60), m_layerTreeHost->deviceViewportSize());
     1773
     1774        m_rootLayer->addChild(m_childLayer);
     1775
     1776        m_rootLayer->setIsDrawable(true);
     1777        m_rootLayer->setBounds(IntSize(30, 30));
     1778        m_rootLayer->setAnchorPoint(FloatPoint(0, 0));
     1779
     1780        m_childLayer->setIsDrawable(true);
     1781        m_childLayer->setPosition(IntPoint(2, 2));
     1782        m_childLayer->setBounds(IntSize(10, 10));
     1783        m_childLayer->setAnchorPoint(FloatPoint(0, 0));
     1784
     1785        m_layerTreeHost->setRootLayer(m_rootLayer);
     1786    }
     1787
     1788    virtual void commitCompleteOnCCThread(CCLayerTreeHostImpl* impl)
     1789    {
     1790        // Get access to protected methods.
     1791        MockLayerTreeHostImpl* mockImpl = static_cast<MockLayerTreeHostImpl*>(impl);
     1792
     1793        // Should only do one commit.
     1794        EXPECT_EQ(0, impl->sourceFrameNumber());
     1795        // Device scale factor should come over to impl.
     1796        EXPECT_NEAR(impl->settings().deviceScaleFactor, 1.5, 0.00001);
     1797
     1798        // Both layers are on impl.
     1799        ASSERT_EQ(1u, impl->rootLayer()->children().size());
     1800
     1801        // Device viewport is scaled.
     1802        EXPECT_EQ(IntSize(40, 40), impl->viewportSize());
     1803        EXPECT_EQ(IntSize(60, 60), impl->deviceViewportSize());
     1804
     1805        CCLayerImpl* root = impl->rootLayer();
     1806        CCLayerImpl* child = impl->rootLayer()->children()[0].get();
     1807
     1808        // Positions remain in layout pixels.
     1809        EXPECT_EQ(IntPoint(0, 0), root->position());
     1810        EXPECT_EQ(IntPoint(2, 2), child->position());
     1811
     1812        // Compute all the layer transforms for the frame.
     1813        MockLayerTreeHostImpl::CCLayerList renderSurfaceLayerList;
     1814        mockImpl->calculateRenderSurfaceLayerList(renderSurfaceLayerList);
     1815
     1816        // Both layers should be drawing into the root render surface.
     1817        ASSERT_EQ(1u, renderSurfaceLayerList.size());
     1818        ASSERT_EQ(root->renderSurface(), renderSurfaceLayerList[0]->renderSurface());
     1819        ASSERT_EQ(2u, root->renderSurface()->layerList().size());
     1820
     1821        // The root render surface is the size of the viewport.
     1822        EXPECT_EQ_RECT(IntRect(0, 0, 60, 60), root->renderSurface()->contentRect());
     1823
     1824        TransformationMatrix scaleTransform;
     1825        scaleTransform.scale(impl->settings().deviceScaleFactor);
     1826
     1827        // The root layer is scaled by 2x.
     1828        TransformationMatrix rootScreenSpaceTransform = scaleTransform;
     1829        TransformationMatrix rootDrawTransform = scaleTransform;
     1830        rootDrawTransform.translate(root->bounds().width() * 0.5, root->bounds().height() * 0.5);
     1831
     1832        EXPECT_EQ(rootDrawTransform, root->drawTransform());
     1833        EXPECT_EQ(rootScreenSpaceTransform, root->screenSpaceTransform());
     1834
     1835        // The child is at position 2,2, so translate by 2,2 before applying the scale by 2x.
     1836        TransformationMatrix childScreenSpaceTransform = scaleTransform;
     1837        childScreenSpaceTransform.translate(2, 2);
     1838        TransformationMatrix childDrawTransform = scaleTransform;
     1839        childDrawTransform.translate(2, 2);
     1840        childDrawTransform.translate(child->bounds().width() * 0.5, child->bounds().height() * 0.5);
     1841
     1842        EXPECT_EQ(childDrawTransform, child->drawTransform());
     1843        EXPECT_EQ(childScreenSpaceTransform, child->screenSpaceTransform());
     1844
     1845        endTest();
     1846    }
     1847
     1848    virtual void afterTest()
     1849    {
     1850        m_rootLayer.clear();
     1851        m_childLayer.clear();
     1852    }
     1853
     1854private:
     1855    MockContentLayerDelegate m_delegate;
     1856    RefPtr<ContentLayerChromium> m_rootLayer;
     1857    RefPtr<ContentLayerChromium> m_childLayer;
     1858};
     1859
     1860TEST_F(CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers, runMultiThread)
     1861{
     1862    runTest(true);
     1863}
    17461864
    17471865// Verify atomicity of commits and reuse of textures.
    … …  
    19982116}
    19992117
    2000 #define EXPECT_EQ_RECT(a, b) \
    2001     EXPECT_EQ(a.x(), b.x()); \
    2002     EXPECT_EQ(a.y(), b.y()); \
    2003     EXPECT_EQ(a.width(), b.width()); \
    2004     EXPECT_EQ(a.height(), b.height());
    2005 
    20062118class TestLayerChromium : public LayerChromium {
    20072119public:

  • trunk/Source/WebKit/chromium/tests/LayerRendererChromiumTest.cpp

    r116779 r117535  
    7272
    7373    // LayerRendererChromiumClient methods.
    74     virtual const IntSize& viewportSize() const OVERRIDE { static IntSize fakeSize; return fakeSize; }
     74    virtual const IntSize& deviceViewportSize() const OVERRIDE { static IntSize fakeSize; return fakeSize; }
    7575    virtual const CCSettings& settings() const OVERRIDE { static CCSettings fakeSettings; return fakeSettings; }
    7676    virtual void didLoseContext() OVERRIDE { }

  • trunk/Source/WebKit/chromium/tests/WebFrameTest.cpp

    r117170 r117535  
    3131#include "config.h"
    3232
     33#include "WebFrame.h"
     34
     35#include "Frame.h"
    3336#include "FrameTestHelpers.h"
    3437#include "ResourceError.h"
    … …  
    3639#include "WebFindOptions.h"
    3740#include "WebFormElement.h"
    38 #include "WebFrame.h"
    3941#include "WebFrameClient.h"
    4042#include "WebRange.h"
    … …  
    234236
    235237    EXPECT_EQ(2, webView->deviceScaleFactor());
     238
     239    // Device scale factor should be a component of page scale factor in fixed-layout, so a scale of 1 becomes 2.
     240    webView->setPageScaleFactorLimits(1, 2);
     241    EXPECT_EQ(2, webView->pageScaleFactor());
     242
     243    // Force the layout to happen before leaving the test.
     244    webView->mainFrame()->contentAsText(1024).utf8();
    236245}
    237246#endif
    238247
    239248#if ENABLE(GESTURE_EVENTS)
    240 TEST_F(WebFrameTest, FAILS_DivAutoZoomParamsTest)
     249TEST_F(WebFrameTest, DivAutoZoomParamsTest)
    241250{
    242251    registerMockedHttpURLLoad("get_scale_for_auto_zoom_into_div_test.html");
    … …  
    298307    EXPECT_FLOAT_EQ(3, scale);
    299308
    300 
    301309    // Test for Non-doubletap scaling
    302310    webViewImpl->setPageScaleFactor(1, WebPoint(0, 0));
    … …  
    306314    webViewImpl->computeScaleAndScrollForHitRect(WebRect(250, 250, 10, 10), WebViewImpl::FindInPage, scale, scroll);
    307315    EXPECT_NEAR(pageWidth / divWidth, scale, 0.1);
     316
     317    // Drop any pending fake mouse events from zooming before leaving the test.
     318    webViewImpl->page()->mainFrame()->eventHandler()->clear();
    308319}
    309320#endif
Note: See TracChangeset for help on using the changeset viewer.