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):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@117535
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2012-05-17 Dana Jansens <danakj@chromium.org>
+
+ [chromium] Scale all compositor output by the defaultDeviceScaleFactor
+ https://bugs.webkit.org/show_bug.cgi?id=86051
+
+ Reviewed by James Robinson.
+
+ * chromium/public/WebLayerTreeView.h:
+ (WebKit::WebLayerTreeView::Settings::Settings):
+ (Settings):
+
2012-05-17 Ami Fischman <fischman@chromium.org>
[Chromium] Store HTTP version in WebURLResponse
, threadedAnimationEnabled(false)
, defaultTileSize(WebSize(256, 256))
, maxUntiledLayerSize(WebSize(512, 512))
+ , deviceScaleFactor(1)
{
}
bool threadedAnimationEnabled;
WebSize defaultTileSize;
WebSize maxUntiledLayerSize;
+ float deviceScaleFactor;
#if WEBKIT_IMPLEMENTATION
operator WebCore::CCSettings() const;
#endif
+2012-05-17 Dana Jansens <danakj@chromium.org>
+
+ [chromium] Scale all compositor output by the defaultDeviceScaleFactor
+ https://bugs.webkit.org/show_bug.cgi?id=86051
+
+ Reviewed by James Robinson.
+
+ 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):
+
2012-05-17 Hayato Ito <hayato@chromium.org>
[Shadow DOM] Add an assertion to make sure a visited node is not an active insertion point.
class LayerRendererChromiumClient {
public:
- virtual const IntSize& viewportSize() const = 0;
+ virtual const IntSize& deviceViewportSize() const = 0;
virtual const CCSettings& settings() const = 0;
virtual void didLoseContext() = 0;
virtual void onSwapBuffersComplete() = 0;
GraphicsContext3D* context();
bool contextSupportsMapSub() const { return m_capabilities.usingMapSub; }
- const IntSize& viewportSize() { return m_client->viewportSize(); }
- int viewportWidth() { return viewportSize().width(); }
- int viewportHeight() { return viewportSize().height(); }
-
void viewportChanged();
void beginDrawingFrame(CCRenderSurface* defaultRenderSurface);
bool initialize();
private:
+ const IntSize& viewportSize() { return m_client->deviceViewportSize(); }
+ int viewportWidth() { return viewportSize().width(); }
+ int viewportHeight() { return viewportSize().height(); }
+
void drawQuad(const CCDrawQuad*, const FloatRect& surfaceDamageRect);
void drawCheckerboardQuad(const CCCheckerboardDrawQuad*);
void drawDebugBorderQuad(const CCDebugBorderDrawQuad*);
// Update m_settings based on partial update capability.
m_settings.maxPartialTextureUpdates = min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates());
- m_contentsTextureManager = TextureManager::create(TextureManager::highLimitBytes(viewportSize()),
- TextureManager::reclaimLimitBytes(viewportSize()),
+ m_contentsTextureManager = TextureManager::create(TextureManager::highLimitBytes(deviceViewportSize()),
+ TextureManager::reclaimLimitBytes(deviceViewportSize()),
m_proxy->layerRendererCapabilities().maxTextureSize);
m_layerRendererInitialized = true;
return;
m_viewportSize = viewportSize;
+
+ m_deviceViewportSize = viewportSize;
+ m_deviceViewportSize.scale(m_settings.deviceScaleFactor);
+
setNeedsCommit();
}
if (!rootLayer->renderSurface())
rootLayer->createRenderSurface();
- rootLayer->renderSurface()->setContentRect(IntRect(IntPoint(0, 0), viewportSize()));
+ rootLayer->renderSurface()->setContentRect(IntRect(IntPoint(0, 0), deviceViewportSize()));
- IntRect rootClipRect(IntPoint(), viewportSize());
+ IntRect rootClipRect(IntPoint(), deviceViewportSize());
rootLayer->setClipRect(rootClipRect);
LayerList updateList;
RenderSurfaceChromium* rootRenderSurface = rootLayer->renderSurface();
rootRenderSurface->clearLayerList();
- TransformationMatrix identityMatrix;
{
TRACE_EVENT("CCLayerTreeHost::updateLayers::calcDrawEtc", this, 0);
- CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootLayer, rootLayer, identityMatrix, identityMatrix, updateList, rootRenderSurface->layerList(), layerRendererCapabilities().maxTextureSize);
+ TransformationMatrix identityMatrix;
+ TransformationMatrix deviceScaleTransform;
+ deviceScaleTransform.scale(m_settings.deviceScaleFactor);
+ CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, updateList, rootRenderSurface->layerList(), layerRendererCapabilities().maxTextureSize);
}
// Reset partial texture update requests.
typedef CCLayerIterator<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium, CCLayerIteratorActions::FrontToBack> CCLayerIteratorType;
bool recordMetricsForFrame = true; // FIXME: In the future, disable this when about:tracing is off.
- CCOcclusionTracker occlusionTracker(IntRect(IntPoint(), viewportSize()), recordMetricsForFrame);
+ CCOcclusionTracker occlusionTracker(IntRect(IntPoint(), deviceViewportSize()), recordMetricsForFrame);
occlusionTracker.setMinimumTrackingSize(CCOcclusionTracker::preferredMinimumTrackingSize());
CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList);
, threadedAnimationEnabled(false)
, maxPartialTextureUpdates(std::numeric_limits<size_t>::max())
, defaultTileSize(IntSize(256, 256))
- , maxUntiledLayerSize(IntSize(512, 512)) { }
+ , maxUntiledLayerSize(IntSize(512, 512))
+ , deviceScaleFactor(1)
+ { }
bool acceleratePainting;
bool showFPSCounter;
size_t maxPartialTextureUpdates;
IntSize defaultTileSize;
IntSize maxUntiledLayerSize;
+ float deviceScaleFactor;
};
// Provides information on an Impl's rendering capabilities back to the CCLayerTreeHost
void setViewportSize(const IntSize&);
const IntSize& viewportSize() const { return m_viewportSize; }
+ // Gives the viewport size in device/content space.
+ const IntSize& deviceViewportSize() const { return m_deviceViewportSize; }
void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor);
CCSettings m_settings;
IntSize m_viewportSize;
+ IntSize m_deviceViewportSize;
bool m_visible;
typedef HashMap<GraphicsContext3D*, RefPtr<RateLimiter> > RateLimiterMap;
RateLimiterMap m_rateLimiters;
if (!m_rootLayerImpl->renderSurface())
m_rootLayerImpl->createRenderSurface();
m_rootLayerImpl->renderSurface()->clearLayerList();
- m_rootLayerImpl->renderSurface()->setContentRect(IntRect(IntPoint(), viewportSize()));
+ m_rootLayerImpl->renderSurface()->setContentRect(IntRect(IntPoint(), deviceViewportSize()));
- m_rootLayerImpl->setClipRect(IntRect(IntPoint(), viewportSize()));
+ m_rootLayerImpl->setClipRect(IntRect(IntPoint(), deviceViewportSize()));
{
- TransformationMatrix identityMatrix;
TRACE_EVENT("CCLayerTreeHostImpl::calcDrawEtc", this, 0);
- CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(m_rootLayerImpl.get(), m_rootLayerImpl.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, m_rootLayerImpl->renderSurface()->layerList(), &m_layerSorter, layerRendererCapabilities().maxTextureSize);
+ TransformationMatrix identityMatrix;
+ TransformationMatrix deviceScaleTransform;
+ deviceScaleTransform.scale(m_settings.deviceScaleFactor);
+ CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(m_rootLayerImpl.get(), m_rootLayerImpl.get(), deviceScaleTransform, identityMatrix, renderSurfaceLayerList, m_rootLayerImpl->renderSurface()->layerList(), &m_layerSorter, layerRendererCapabilities().maxTextureSize);
}
}
if (layerRendererCapabilities().usingPartialSwap)
scissorRect = enclosingIntRect(m_rootDamageRect);
else
- scissorRect = IntRect(IntPoint(), viewportSize());
+ scissorRect = IntRect(IntPoint(), deviceViewportSize());
bool recordMetricsForFrame = true; // FIXME: In the future, disable this when about:tracing is off.
CCOcclusionTrackerImpl occlusionTracker(scissorRect, recordMetricsForFrame);
return;
m_viewportSize = viewportSize;
+
+ m_deviceViewportSize = viewportSize;
+ m_deviceViewportSize.scale(m_settings.deviceScaleFactor);
+
updateMaxScrollPosition();
if (m_layerRenderer)
viewBounds = clipLayer->bounds();
}
viewBounds.scale(1 / m_pageScaleDelta);
+ viewBounds.scale(m_settings.deviceScaleFactor);
+ // maxScroll is computed in physical pixels, but scroll positions are in layout pixels.
IntSize maxScroll = contentSize() - expandedIntSize(viewBounds);
+ maxScroll.scale(1 / m_settings.deviceScaleFactor);
// The viewport may be larger than the contents in some cases, such as
// having a vertical scrollbar but no horizontal overflow.
maxScroll.clampNegativeToZero();
return ScrollFailed;
}
- IntPoint scrollLayerContentPoint(m_scrollLayerImpl->screenSpaceTransform().inverse().mapPoint(viewportPoint));
- if (m_scrollLayerImpl->nonFastScrollableRegion().contains(scrollLayerContentPoint)) {
+ IntPoint deviceViewportPoint = viewportPoint;
+ deviceViewportPoint.scale(m_settings.deviceScaleFactor, m_settings.deviceScaleFactor);
+
+ // The inverse of the screen space transform takes us from physical pixels to layout pixels.
+ IntPoint scrollLayerPoint(m_scrollLayerImpl->screenSpaceTransform().inverse().mapPoint(deviceViewportPoint));
+
+ if (m_scrollLayerImpl->nonFastScrollableRegion().contains(scrollLayerPoint)) {
TRACE_EVENT("scrollBegin Failed nonFastScrollableRegion", this, 0);
return ScrollFailed;
}
FloatSize scrollEnd = scrollBegin + anchor;
scrollEnd.scale(m_minPageScale / scaleBegin);
scrollEnd -= anchor;
- scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_viewportSize)).expandedTo(FloatSize(0, 0));
+ scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceViewportSize)).expandedTo(FloatSize(0, 0));
scrollEnd.scale(1 / pageScaleDeltaToSend);
+ scrollEnd.scale(m_settings.deviceScaleFactor);
makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScale);
}
void didDrawAllLayers(const FrameData&);
// LayerRendererChromiumClient implementation
- virtual const IntSize& viewportSize() const OVERRIDE { return m_viewportSize; }
+ virtual const IntSize& deviceViewportSize() const OVERRIDE { return m_deviceViewportSize; }
virtual const CCSettings& settings() const OVERRIDE { return m_settings; }
virtual void didLoseContext() OVERRIDE;
virtual void onSwapBuffersComplete() OVERRIDE;
int sourceFrameNumber() const { return m_sourceFrameNumber; }
void setSourceFrameNumber(int frameNumber) { m_sourceFrameNumber = frameNumber; }
+ const IntSize& viewportSize() const { return m_viewportSize; }
void setViewportSize(const IntSize&);
- void setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale);
float pageScale() const { return m_pageScale; }
+ void setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale);
PassOwnPtr<CCScrollAndScaleSet> processScrollDeltas();
void animatePageScale(double monotonicTime);
void animateGestures(double monotonicTime);
+ // Exposed for testing.
+ void calculateRenderSurfaceLayerList(CCLayerList&);
+
// Virtual for testing.
virtual void animateLayers(double monotonicTime, double wallClockTime);
void adjustScrollsForPageScaleChange(float);
void updateMaxScrollPosition();
void trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList);
- void calculateRenderSurfaceLayerList(CCLayerList&);
// Returns false if the frame should not be displayed. This function should
// only be called from prepareToDraw, as didDrawAllLayers must be called
CCLayerImpl* m_scrollLayerImpl;
CCSettings m_settings;
IntSize m_viewportSize;
+ IntSize m_deviceViewportSize;
bool m_visible;
OwnPtr<CCHeadsUpDisplay> m_headsUpDisplay;
+2012-05-17 Dana Jansens <danakj@chromium.org>
+
+ [chromium] Scale all compositor output by the defaultDeviceScaleFactor
+ https://bugs.webkit.org/show_bug.cgi?id=86051
+
+ Reviewed by James Robinson.
+
+ 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):
+
2012-05-17 Vangelis Kokkevis <vangelis@chromium.org>
Expose layer tiling size options to WebSettings.
virtual void setMinimumFontSize(int) = 0;
virtual void setMinimumLogicalFontSize(int) = 0;
virtual void setDefaultDeviceScaleFactor(int) = 0;
+ virtual void setApplyDefaultDeviceScaleFactorInCompositor(bool) = 0;
virtual void setDefaultTextEncodingName(const WebString&) = 0;
virtual void setJavaScriptEnabled(bool) = 0;
virtual void setWebSecurityEnabled(bool) = 0;
NonCompositedContentHost::NonCompositedContentHost(PassOwnPtr<WebCore::LayerPainterChromium> contentPaint)
: m_contentPaint(contentPaint)
, m_showDebugBorders(false)
+ , m_deviceScaleFactor(1.0)
{
m_graphicsLayer = WebCore::GraphicsLayer::create(this);
#ifndef NDEBUG
layer->setAlwaysReserveTextures(true);
}
-void NonCompositedContentHost::setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, float pageScale, int layerAdjustX)
+void NonCompositedContentHost::setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, float deviceScale, int layerAdjustX)
{
if (!scrollLayer())
return;
// Due to the possibility of pinch zoom, the noncomposited layer is always
// assumed to be scrollable.
scrollLayer()->setScrollable(true);
+ m_deviceScaleFactor = deviceScale;
+ m_graphicsLayer->deviceOrPageScaleFactorChanged();
m_graphicsLayer->setSize(contentsSize);
m_layerAdjustX = layerAdjustX;
} else if (visibleRectChanged)
m_graphicsLayer->setNeedsDisplay();
- if (m_graphicsLayer->pageScaleFactor() != pageScale)
- m_graphicsLayer->deviceOrPageScaleFactorChanged();
-
WebCore::LayerChromium* clipLayer = scrollLayer()->parent();
WebCore::LayerChromium* rootLayer = clipLayer;
while (rootLayer->parent())
void invalidateRect(const WebCore::IntRect&);
void setBackgroundColor(const WebCore::Color&);
void setScrollLayer(WebCore::GraphicsLayer*);
- void setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, float pageScale, int layerAdjustX);
+ void setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, float deviceScale, int layerAdjustX);
void protectVisibleTileTextures();
WebCore::GraphicsLayer* topLevelRootLayer() const { return m_graphicsLayer.get(); }
virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect);
virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;
virtual bool showRepaintCounter(const WebCore::GraphicsLayer*) const;
+ // The deviceScaleFactor given to the GraphicsLayer can be non-1 when the
+ // contents are scaled in the compositor instead of by the pageScaleFactor.
+ // However, the pageScaleFactor is always baked into the GraphicsLayer's
+ // size, so it is always 1 for the GraphicsLayer.
+ virtual float deviceScaleFactor() const OVERRIDE { return m_deviceScaleFactor; }
WebCore::LayerChromium* scrollLayer();
WebCore::IntSize m_viewportSize;
int m_layerAdjustX;
bool m_showDebugBorders;
+ float m_deviceScaleFactor;
};
} // namespace WebKit
settings.threadedAnimationEnabled = threadedAnimationEnabled;
settings.defaultTileSize = defaultTileSize;
settings.maxUntiledLayerSize = maxUntiledLayerSize;
+ settings.deviceScaleFactor = deviceScaleFactor;
// FIXME: showFPSCounter / showPlatformLayerTree / maxPartialTextureUpdates aren't supported currently.
return settings;
, m_showPlatformLayerTree(false)
, m_showPaintRects(false)
, m_viewportEnabled(false)
+ , m_applyDefaultDeviceScaleFactorInCompositor(false)
, m_defaultTileSize(WebSize(256, 256))
, m_maxUntiledLayerSize(WebSize(512, 512))
{
m_settings->setDefaultDeviceScaleFactor(defaultDeviceScaleFactor);
}
+void WebSettingsImpl::setApplyDefaultDeviceScaleFactorInCompositor(bool applyDefaultDeviceScaleFactorInCompositor)
+{
+ m_applyDefaultDeviceScaleFactorInCompositor = applyDefaultDeviceScaleFactorInCompositor;
+}
+
void WebSettingsImpl::setDefaultTextEncodingName(const WebString& encoding)
{
m_settings->setDefaultTextEncodingName((String)encoding);
virtual void setMinimumFontSize(int);
virtual void setMinimumLogicalFontSize(int);
virtual void setDefaultDeviceScaleFactor(int);
+ virtual void setApplyDefaultDeviceScaleFactorInCompositor(bool);
virtual void setDefaultTextEncodingName(const WebString&);
virtual void setJavaScriptEnabled(bool);
virtual void setWebSecurityEnabled(bool);
bool showFPSCounter() const { return m_showFPSCounter; }
bool showPlatformLayerTree() const { return m_showPlatformLayerTree; }
bool showPaintRects() const { return m_showPaintRects; }
+ bool applyDefaultDeviceScaleFactorInCompositor() const { return m_applyDefaultDeviceScaleFactorInCompositor; }
WebSize defaultTileSize() const { return m_defaultTileSize; }
WebSize maxUntiledLayerSize() const { return m_maxUntiledLayerSize; }
bool m_showPlatformLayerTree;
bool m_showPaintRects;
bool m_viewportEnabled;
+ bool m_applyDefaultDeviceScaleFactorInCompositor;
WebSize m_defaultTileSize;
WebSize m_maxUntiledLayerSize;
};
, m_compositorCreationFailed(false)
, m_recreatingGraphicsContext(false)
, m_compositorSurfaceReady(false)
+ , m_deviceScaleInCompositor(1)
#endif
#if ENABLE(INPUT_SPEECH)
, m_speechInputClient(SpeechInputClientImpl::create(client))
if (!scaleFactor)
scaleFactor = 1;
+ if (m_deviceScaleInCompositor != 1) {
+ // Don't allow page scaling when compositor scaling is being used,
+ // as they are currently incompatible.
+ ASSERT(scaleFactor == 1);
+ }
+
scaleFactor = clampPageScaleFactorToLimits(scaleFactor);
WebPoint clampedOrigin = clampOffsetAtScale(origin, scaleFactor);
page()->setPageScaleFactor(scaleFactor, clampedOrigin);
return;
page()->setDeviceScaleFactor(scaleFactor);
+
+ if (m_deviceScaleInCompositor != 1) {
+ // Don't allow page scaling when compositor scaling is being used,
+ // as they are currently incompatible. This means the deviceScale
+ // needs to match the one in the compositor.
+ ASSERT(scaleFactor == m_deviceScaleInCompositor);
+ }
}
bool WebViewImpl::isFixedLayoutModeEnabled() const
#if USE(ACCELERATED_COMPOSITING)
// Also notify the base layer, which RenderLayerCompositor does not see.
- if (m_nonCompositedContentHost) {
- m_nonCompositedContentHost->topLevelRootLayer()->deviceOrPageScaleFactorChanged();
+ if (m_nonCompositedContentHost)
updateLayerTreeViewport();
- }
#endif
}
if (!mainFrame() || !page() || !page()->mainFrame() || !page()->mainFrame()->view())
return false;
- m_minimumPageScaleFactor = min(max(m_pageDefinedMinimumPageScaleFactor, minPageScaleFactor), maxPageScaleFactor) * deviceScaleFactor();
- m_maximumPageScaleFactor = max(min(m_pageDefinedMaximumPageScaleFactor, maxPageScaleFactor), minPageScaleFactor) * deviceScaleFactor();
+ m_minimumPageScaleFactor = min(max(m_pageDefinedMinimumPageScaleFactor, minPageScaleFactor), maxPageScaleFactor) * (deviceScaleFactor() / m_deviceScaleInCompositor);
+ m_maximumPageScaleFactor = max(min(m_pageDefinedMaximumPageScaleFactor, maxPageScaleFactor), minPageScaleFactor) * (deviceScaleFactor() / m_deviceScaleInCompositor);
int viewWidthNotIncludingScrollbars = page()->mainFrame()->view()->visibleContentRect(false).width();
int contentsWidth = mainFrame()->contentsSize().width;
m_nonCompositedContentHost = NonCompositedContentHost::create(WebViewImplContentPainter::create(this));
m_nonCompositedContentHost->setShowDebugBorders(page()->settings()->showDebugBorders());
+ if (m_webSettings->applyDefaultDeviceScaleFactorInCompositor() && page()->settings()->defaultDeviceScaleFactor() != 1) {
+ ASSERT(page()->settings()->defaultDeviceScaleFactor());
+
+ m_deviceScaleInCompositor = page()->settings()->defaultDeviceScaleFactor();
+ layerTreeViewSettings.deviceScaleFactor = m_deviceScaleInCompositor;
+ setDeviceScaleFactor(m_deviceScaleInCompositor);
+ // When applying a scale factor in the compositor, we disallow page
+ // scaling as they are currently incompatible.
+ setPageScaleFactorLimits(1, 1);
+ }
+
m_layerTreeView.initialize(this, m_rootLayer, layerTreeViewSettings);
if (!m_layerTreeView.isNull()) {
m_layerTreeView.setPageScaleFactorAndLimits(pageScaleFactor(), m_minimumPageScaleFactor, m_maximumPageScaleFactor);
// layer.
layerAdjustX = -view->contentsSize().width() + view->visibleContentRect(false).width();
}
- m_nonCompositedContentHost->setViewport(visibleRect.size(), view->contentsSize(), scroll, pageScaleFactor(), layerAdjustX);
+
+ // This part of the deviceScale will be used to scale the contents of
+ // the NCCH's GraphicsLayer.
+ float deviceScale = m_deviceScaleInCompositor;
+ m_nonCompositedContentHost->setViewport(visibleRect.size(), view->contentsSize(), scroll, deviceScale, layerAdjustX);
+
m_layerTreeView.setViewportSize(size());
m_layerTreeView.setPageScaleFactorAndLimits(pageScaleFactor(), m_minimumPageScaleFactor, m_maximumPageScaleFactor);
}
// If true, the graphics context is being restored.
bool m_recreatingGraphicsContext;
bool m_compositorSurfaceReady;
+ float m_deviceScaleInCompositor;
#endif
static const WebInputEvent* m_currentInputEvent;
using namespace WebKitTests;
using namespace WTF;
+#define EXPECT_EQ_RECT(a, b) \
+ EXPECT_EQ(a.x(), b.x()); \
+ EXPECT_EQ(a.y(), b.y()); \
+ EXPECT_EQ(a.width(), b.width()); \
+ EXPECT_EQ(a.height(), b.height());
+
namespace {
// Used by test stubs to notify the test when something interesting happens.
m_testHooks->drawLayersOnCCThread(this);
}
+ // Make these public.
+ typedef Vector<CCLayerImpl*> CCLayerList;
+ using CCLayerTreeHostImpl::calculateRenderSurfaceLayerList;
+
protected:
virtual void animateLayers(double monotonicTime, double wallClockTime)
{
virtual PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHostImpl(CCLayerTreeHostImplClient* client)
{
// For these tests, we will enable threaded animations.
- CCSettings settings;
- settings.threadedAnimationEnabled = true;
- return MockLayerTreeHostImpl::create(m_testHooks, settings, client);
+ CCSettings copySettings = settings();
+ copySettings.threadedAnimationEnabled = true;
+ return MockLayerTreeHostImpl::create(m_testHooks, copySettings, client);
}
private:
void notifySyncRequired() { }
};
+class CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers : public CCLayerTreeHostTest {
+public:
+
+ CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers()
+ : m_rootLayer(ContentLayerChromium::create(&m_delegate))
+ , m_childLayer(ContentLayerChromium::create(&m_delegate))
+ {
+ m_settings.deviceScaleFactor = 1.5;
+ }
+
+ virtual void beginTest()
+ {
+ // The device viewport should be scaled by the device scale factor.
+ m_layerTreeHost->setViewportSize(IntSize(40, 40));
+ EXPECT_EQ(IntSize(40, 40), m_layerTreeHost->viewportSize());
+ EXPECT_EQ(IntSize(60, 60), m_layerTreeHost->deviceViewportSize());
+
+ m_rootLayer->addChild(m_childLayer);
+
+ m_rootLayer->setIsDrawable(true);
+ m_rootLayer->setBounds(IntSize(30, 30));
+ m_rootLayer->setAnchorPoint(FloatPoint(0, 0));
+
+ m_childLayer->setIsDrawable(true);
+ m_childLayer->setPosition(IntPoint(2, 2));
+ m_childLayer->setBounds(IntSize(10, 10));
+ m_childLayer->setAnchorPoint(FloatPoint(0, 0));
+
+ m_layerTreeHost->setRootLayer(m_rootLayer);
+ }
+
+ virtual void commitCompleteOnCCThread(CCLayerTreeHostImpl* impl)
+ {
+ // Get access to protected methods.
+ MockLayerTreeHostImpl* mockImpl = static_cast<MockLayerTreeHostImpl*>(impl);
+
+ // Should only do one commit.
+ EXPECT_EQ(0, impl->sourceFrameNumber());
+ // Device scale factor should come over to impl.
+ EXPECT_NEAR(impl->settings().deviceScaleFactor, 1.5, 0.00001);
+
+ // Both layers are on impl.
+ ASSERT_EQ(1u, impl->rootLayer()->children().size());
+
+ // Device viewport is scaled.
+ EXPECT_EQ(IntSize(40, 40), impl->viewportSize());
+ EXPECT_EQ(IntSize(60, 60), impl->deviceViewportSize());
+
+ CCLayerImpl* root = impl->rootLayer();
+ CCLayerImpl* child = impl->rootLayer()->children()[0].get();
+
+ // Positions remain in layout pixels.
+ EXPECT_EQ(IntPoint(0, 0), root->position());
+ EXPECT_EQ(IntPoint(2, 2), child->position());
+
+ // Compute all the layer transforms for the frame.
+ MockLayerTreeHostImpl::CCLayerList renderSurfaceLayerList;
+ mockImpl->calculateRenderSurfaceLayerList(renderSurfaceLayerList);
+
+ // Both layers should be drawing into the root render surface.
+ ASSERT_EQ(1u, renderSurfaceLayerList.size());
+ ASSERT_EQ(root->renderSurface(), renderSurfaceLayerList[0]->renderSurface());
+ ASSERT_EQ(2u, root->renderSurface()->layerList().size());
+
+ // The root render surface is the size of the viewport.
+ EXPECT_EQ_RECT(IntRect(0, 0, 60, 60), root->renderSurface()->contentRect());
+
+ TransformationMatrix scaleTransform;
+ scaleTransform.scale(impl->settings().deviceScaleFactor);
+
+ // The root layer is scaled by 2x.
+ TransformationMatrix rootScreenSpaceTransform = scaleTransform;
+ TransformationMatrix rootDrawTransform = scaleTransform;
+ rootDrawTransform.translate(root->bounds().width() * 0.5, root->bounds().height() * 0.5);
+
+ EXPECT_EQ(rootDrawTransform, root->drawTransform());
+ EXPECT_EQ(rootScreenSpaceTransform, root->screenSpaceTransform());
+
+ // The child is at position 2,2, so translate by 2,2 before applying the scale by 2x.
+ TransformationMatrix childScreenSpaceTransform = scaleTransform;
+ childScreenSpaceTransform.translate(2, 2);
+ TransformationMatrix childDrawTransform = scaleTransform;
+ childDrawTransform.translate(2, 2);
+ childDrawTransform.translate(child->bounds().width() * 0.5, child->bounds().height() * 0.5);
+
+ EXPECT_EQ(childDrawTransform, child->drawTransform());
+ EXPECT_EQ(childScreenSpaceTransform, child->screenSpaceTransform());
+
+ endTest();
+ }
+
+ virtual void afterTest()
+ {
+ m_rootLayer.clear();
+ m_childLayer.clear();
+ }
+
+private:
+ MockContentLayerDelegate m_delegate;
+ RefPtr<ContentLayerChromium> m_rootLayer;
+ RefPtr<ContentLayerChromium> m_childLayer;
+};
+
+TEST_F(CCLayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers, runMultiThread)
+{
+ runTest(true);
+}
+
// Verify atomicity of commits and reuse of textures.
class CCLayerTreeHostTestAtomicCommit : public CCLayerTreeHostTest {
public:
runTest(true);
}
-#define EXPECT_EQ_RECT(a, b) \
- EXPECT_EQ(a.x(), b.x()); \
- EXPECT_EQ(a.y(), b.y()); \
- EXPECT_EQ(a.width(), b.width()); \
- EXPECT_EQ(a.height(), b.height());
-
class TestLayerChromium : public LayerChromium {
public:
static PassRefPtr<TestLayerChromium> create() { return adoptRef(new TestLayerChromium()); }
}
// LayerRendererChromiumClient methods.
- virtual const IntSize& viewportSize() const OVERRIDE { static IntSize fakeSize; return fakeSize; }
+ virtual const IntSize& deviceViewportSize() const OVERRIDE { static IntSize fakeSize; return fakeSize; }
virtual const CCSettings& settings() const OVERRIDE { static CCSettings fakeSettings; return fakeSettings; }
virtual void didLoseContext() OVERRIDE { }
virtual void onSwapBuffersComplete() OVERRIDE { }
#include "config.h"
+#include "WebFrame.h"
+
+#include "Frame.h"
#include "FrameTestHelpers.h"
#include "ResourceError.h"
#include "WebDocument.h"
#include "WebFindOptions.h"
#include "WebFormElement.h"
-#include "WebFrame.h"
#include "WebFrameClient.h"
#include "WebRange.h"
#include "WebScriptSource.h"
webView->layout();
EXPECT_EQ(2, webView->deviceScaleFactor());
+
+ // Device scale factor should be a component of page scale factor in fixed-layout, so a scale of 1 becomes 2.
+ webView->setPageScaleFactorLimits(1, 2);
+ EXPECT_EQ(2, webView->pageScaleFactor());
+
+ // Force the layout to happen before leaving the test.
+ webView->mainFrame()->contentAsText(1024).utf8();
}
#endif
#if ENABLE(GESTURE_EVENTS)
-TEST_F(WebFrameTest, FAILS_DivAutoZoomParamsTest)
+TEST_F(WebFrameTest, DivAutoZoomParamsTest)
{
registerMockedHttpURLLoad("get_scale_for_auto_zoom_into_div_test.html");
webViewImpl->computeScaleAndScrollForHitRect(doubleTapPoint, WebViewImpl::DoubleTap, scale, scroll);
EXPECT_FLOAT_EQ(3, scale);
-
// Test for Non-doubletap scaling
webViewImpl->setPageScaleFactor(1, WebPoint(0, 0));
webViewImpl->setDeviceScaleFactor(4);
// Test zooming into div.
webViewImpl->computeScaleAndScrollForHitRect(WebRect(250, 250, 10, 10), WebViewImpl::FindInPage, scale, scroll);
EXPECT_NEAR(pageWidth / divWidth, scale, 0.1);
+
+ // Drop any pending fake mouse events from zooming before leaving the test.
+ webViewImpl->page()->mainFrame()->eventHandler()->clear();
}
#endif
projects / profile / ivi / webkit-efl.git / commitdiff