Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(3606)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/CCLayerTreeHostImpl.cpp

Issue 10916279: Chromium compositor change implementing page-scale driven pinch-zoom. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: Rebaseline to 158365. Created 8 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/CCLayerTreeHostImpl.h ('k') | cc/CCLayerTreeHostImplTest.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/CCLayerTreeHostImpl.cpp
===================================================================
--- cc/CCLayerTreeHostImpl.cpp (revision 158365)
+++ cc/CCLayerTreeHostImpl.cpp (working copy)
@@ -48,6 +48,49 @@
namespace cc {
+FloatRect CCPinchZoomViewport::bounds() const
+{
+ FloatSize scaledBounds = m_unpinchedBounds;
+ if (m_pageScaleFactor > 1)
+ scaledBounds.scale(1 / m_pageScaleFactor);
aelias_OOO_until_Jul13 2012/09/25 03:53:29 On Android, < 1 pageScaleFactors are common. I th
+
+ FloatRect bounds;
+ bounds.setSize(scaledBounds);
+ bounds.setLocation(m_pinchViewportScrollDelta);
+
+ return bounds;
+}
+
+FloatSize CCPinchZoomViewport::applyScroll(FloatSize& delta)
+{
+ FloatSize overflow;
+ FloatRect pinchedBounds = bounds();
+
+ pinchedBounds.move(delta);
+ if (pinchedBounds.x() < 0) {
+ pinchedBounds.setX(0);
+ overflow.setWidth(pinchedBounds.x());
+ }
+
+ if (pinchedBounds.y() < 0) {
+ pinchedBounds.setY(0);
+ overflow.setHeight(pinchedBounds.y());
+ }
+
+ if (pinchedBounds.maxX() > m_unpinchedBounds.width()) {
+ pinchedBounds.move(m_unpinchedBounds.width() - pinchedBounds.maxX(), 0);
+ overflow.setWidth(pinchedBounds.maxX() - m_unpinchedBounds.width());
+ }
+
+ if (pinchedBounds.maxY() > m_unpinchedBounds.height()) {
+ pinchedBounds.move(0, m_unpinchedBounds.height() - pinchedBounds.maxY());
+ overflow.setHeight(pinchedBounds.maxY() - m_unpinchedBounds.height());
+ }
+ m_pinchViewportScrollDelta = pinchedBounds.location();
+
+ return overflow;
+}
+
class CCLayerTreeHostImplTimeSourceAdapter : public CCTimeSourceClient {
WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImplTimeSourceAdapter);
public:
@@ -115,11 +158,11 @@
, m_visible(true)
, m_contentsTexturesPurged(false)
, m_memoryAllocationLimitBytes(CCPrioritizedTextureManager::defaultMemoryAllocationLimit())
- , m_pageScale(1)
+ , m_pageScaleFactor(1)
, m_pageScaleDelta(1)
, m_sentPageScaleDelta(1)
- , m_minPageScale(0)
- , m_maxPageScale(0)
+ , m_minPageScaleFactor(0)
+ , m_maxPageScaleFactor(0)
, m_backgroundColor(0)
, m_hasTransparentBackground(false)
, m_needsAnimateLayers(false)
@@ -196,7 +239,7 @@
IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
scrollTotal.scale(m_pageScaleDelta);
- float scaleTotal = m_pageScale * m_pageScaleDelta;
+ float scaleTotal = m_pageScaleFactor * m_pageScaleDelta;
IntSize scaledContentSize = contentSize();
scaledContentSize.scale(m_pageScaleDelta);
@@ -233,6 +276,13 @@
}
}
+void CCLayerTreeHostImpl::updateRootScrollLayerImplTransform()
+{
+ if (m_rootScrollLayerImpl) {
+ m_rootScrollLayerImpl->setImplTransform(implTransform());
+ }
+}
+
void CCLayerTreeHostImpl::calculateRenderSurfaceLayerList(CCLayerList& renderSurfaceLayerList)
{
ASSERT(renderSurfaceLayerList.isEmpty());
@@ -240,6 +290,8 @@
ASSERT(m_renderer); // For maxTextureSize.
{
+ updateRootScrollLayerImplTransform();
+
TRACE_EVENT0("cc", "CCLayerTreeHostImpl::calcDrawEtc");
CCLayerTreeHostCommon::calculateDrawTransforms(m_rootLayerImpl.get(), deviceViewportSize(), m_deviceScaleFactor, &m_layerSorter, rendererCapabilities().maxTextureSize, renderSurfaceLayerList);
CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
@@ -767,6 +819,8 @@
m_layoutViewportSize = layoutViewportSize;
m_deviceViewportSize = deviceViewportSize;
+ m_pinchZoomViewport.setUnpinchedBounds(FloatSize(layoutViewportSize));
+
updateMaxScrollPosition();
if (m_renderer)
@@ -801,38 +855,38 @@
}
-void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale)
+void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
{
- if (!pageScale)
+ if (!pageScaleFactor)
return;
- if (m_sentPageScaleDelta == 1 && pageScale == m_pageScale && minPageScale == m_minPageScale && maxPageScale == m_maxPageScale)
+ if (m_sentPageScaleDelta == 1 && pageScaleFactor == m_pageScaleFactor && minPageScaleFactor == m_minPageScaleFactor && maxPageScaleFactor == m_maxPageScaleFactor)
return;
- m_minPageScale = minPageScale;
- m_maxPageScale = maxPageScale;
+ m_minPageScaleFactor = minPageScaleFactor;
+ m_maxPageScaleFactor = maxPageScaleFactor;
- float pageScaleChange = pageScale / m_pageScale;
- m_pageScale = pageScale;
+ float pageScaleChange = pageScaleFactor / m_pageScaleFactor;
+ m_pageScaleFactor = pageScaleFactor;
- if (pageScaleChange != 1)
- adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
+ if (!CCSettings::pageScalePinchZoomEnabled()) {
+ if (pageScaleChange != 1)
+ adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
+ }
// Clamp delta to limits and refresh display matrix.
setPageScaleDelta(m_pageScaleDelta / m_sentPageScaleDelta);
m_sentPageScaleDelta = 1;
- if (m_rootScrollLayerImpl)
- m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta);
}
void CCLayerTreeHostImpl::setPageScaleDelta(float delta)
{
// Clamp to the current min/max limits.
- float finalMagnifyScale = m_pageScale * delta;
- if (m_minPageScale && finalMagnifyScale < m_minPageScale)
- delta = m_minPageScale / m_pageScale;
- else if (m_maxPageScale && finalMagnifyScale > m_maxPageScale)
- delta = m_maxPageScale / m_pageScale;
+ float finalMagnifyScale = m_pageScaleFactor * delta;
+ if (m_minPageScaleFactor && finalMagnifyScale < m_minPageScaleFactor)
+ delta = m_minPageScaleFactor / m_pageScaleFactor;
+ else if (m_maxPageScaleFactor && finalMagnifyScale > m_maxPageScaleFactor)
+ delta = m_maxPageScaleFactor / m_pageScaleFactor;
if (delta == m_pageScaleDelta)
return;
@@ -840,8 +894,6 @@
m_pageScaleDelta = delta;
updateMaxScrollPosition();
- if (m_rootScrollLayerImpl)
- m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta);
}
void CCLayerTreeHostImpl::updateMaxScrollPosition()
@@ -857,11 +909,22 @@
viewBounds.scale(m_deviceScaleFactor);
}
}
- viewBounds.scale(1 / m_pageScaleDelta);
- // maxScroll is computed in physical pixels, but scroll positions are in layout pixels.
- IntSize maxScroll = contentSize() - expandedIntSize(viewBounds);
+
+ IntSize contentBounds = contentSize();
+ if (CCSettings::pageScalePinchZoomEnabled()) {
+ // Pinch with pageScale scrolls entirely in layout space. contentSize
+ // returns the bounds including the page scale factor, so calculate the
+ // pre page-scale layout size here.
+ contentBounds.setWidth(contentBounds.width() / m_pageScaleFactor);
+ contentBounds.setHeight(contentBounds.height() / m_pageScaleFactor);
+ } else {
+ viewBounds.scale(1 / m_pageScaleDelta);
+ }
+
+ IntSize maxScroll = contentBounds - expandedIntSize(viewBounds);
maxScroll.scale(1 / m_deviceScaleFactor);
+
// The viewport may be larger than the contents in some cases, such as
// having a vertical scrollbar but no horizontal overflow.
maxScroll.clampNegativeToZero();
@@ -944,7 +1007,7 @@
return ScrollIgnored;
}
-static FloatSize scrollLayerWithScreenSpaceDelta(CCLayerImpl& layerImpl, const FloatPoint& screenSpacePoint, const FloatSize& screenSpaceDelta)
+static FloatSize scrollLayerWithScreenSpaceDelta(CCPinchZoomViewport* viewport, CCLayerImpl& layerImpl, const FloatPoint& screenSpacePoint, const FloatSize& screenSpaceDelta)
{
// Layers with non-invertible screen space transforms should not have passed the scroll hit
// test in the first place.
@@ -966,8 +1029,11 @@
// Apply the scroll delta.
FloatSize previousDelta(layerImpl.scrollDelta());
- layerImpl.scrollBy(localEndPoint - localStartPoint);
+ FloatSize unscrolled = layerImpl.scrollBy(localEndPoint - localStartPoint);
+ if (viewport)
+ viewport->applyScroll(unscrolled);
+
// Calculate the applied scroll delta in screen space coordinates.
FloatPoint actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() - previousDelta;
FloatPoint actualScreenSpaceEndPoint = CCMathUtil::mapPoint(layerImpl.screenSpaceTransform(), actualLocalEndPoint, endClipped);
@@ -998,9 +1064,10 @@
if (!layerImpl->scrollable())
continue;
+ CCPinchZoomViewport* viewport = layerImpl == m_rootScrollLayerImpl ? &m_pinchZoomViewport : 0;
FloatSize appliedDelta;
if (m_scrollDeltaIsInScreenSpace)
- appliedDelta = scrollLayerWithScreenSpaceDelta(*layerImpl, viewportPoint, pendingDelta);
+ appliedDelta = scrollLayerWithScreenSpaceDelta(viewport, *layerImpl, viewportPoint, pendingDelta);
else
appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta);
@@ -1071,9 +1138,16 @@
FloatSize move = previousScaleAnchor - newScaleAnchor;
m_previousPinchAnchor = anchor;
+ m_pinchZoomViewport.setTotalPageScaleFactor(m_pageScaleFactor * m_pageScaleDelta);
aelias_OOO_until_Jul13 2012/09/25 03:53:29 This needs to be updated whenever m_pageScaleFacto
- m_rootScrollLayerImpl->scrollBy(roundedIntSize(move));
+ if (CCSettings::pageScalePinchZoomEnabled()) {
+ // Compute the application of the delta with respect to the current page zoom of the page.
+ move.scale(1 / (m_pageScaleFactor * m_deviceScaleFactor));
+ }
+ FloatSize scrollOverflow = CCSettings::pageScalePinchZoomEnabled()? m_pinchZoomViewport.applyScroll(move) : move;
+ m_rootScrollLayerImpl->scrollBy(roundedIntSize(scrollOverflow));
+
if (m_rootScrollLayerImpl->scrollbarAnimationController())
m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUpdate();
@@ -1095,7 +1169,7 @@
{
float pageScale = m_pageScaleAnimation->finalPageScale();
IntSize scrollOffset = m_pageScaleAnimation->finalScrollOffset();
- scrollOffset.scale(m_pageScale / pageScale);
+ scrollOffset.scale(m_pageScaleFactor / pageScale);
makeScrollAndScaleSet(scrollInfo, scrollOffset, pageScale);
}
@@ -1115,20 +1189,20 @@
// out from the anchor point.
IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
scrollBegin.scale(m_pageScaleDelta);
- float scaleBegin = m_pageScale * m_pageScaleDelta;
- float pageScaleDeltaToSend = m_minPageScale / m_pageScale;
+ float scaleBegin = m_pageScaleFactor * m_pageScaleDelta;
+ float pageScaleDeltaToSend = m_minPageScaleFactor / m_pageScaleFactor;
FloatSize scaledContentsSize = contentSize();
scaledContentsSize.scale(pageScaleDeltaToSend);
FloatSize anchor = toSize(m_previousPinchAnchor);
FloatSize scrollEnd = scrollBegin + anchor;
- scrollEnd.scale(m_minPageScale / scaleBegin);
+ scrollEnd.scale(m_minPageScaleFactor / scaleBegin);
scrollEnd -= anchor;
scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceViewportSize)).expandedTo(FloatSize(0, 0));
scrollEnd.scale(1 / pageScaleDeltaToSend);
scrollEnd.scale(m_deviceScaleFactor);
- makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScale);
+ makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScaleFactor);
}
void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale)
@@ -1141,7 +1215,7 @@
scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosition());
scrollInfo->scrolls.append(scroll);
m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
- m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScale;
+ m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScaleFactor;
}
static void collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* layerImpl)
@@ -1168,10 +1242,14 @@
if (m_pinchGestureActive || m_pageScaleAnimation) {
m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1;
- if (m_pinchGestureActive)
- computePinchZoomDeltas(scrollInfo.get());
- else if (m_pageScaleAnimation.get())
- computeDoubleTapZoomDeltas(scrollInfo.get());
+ // If pinch zoom is applied in the impl thread, then there is no need to
+ // calculate these intermediate scale deltas.
+ if (!CCSettings::pageScalePinchZoomEnabled()) {
+ if (m_pinchGestureActive)
+ computePinchZoomDeltas(scrollInfo.get());
+ else if (m_pageScaleAnimation.get())
+ computeDoubleTapZoomDeltas(scrollInfo.get());
+ }
return scrollInfo.release();
}
@@ -1181,6 +1259,22 @@
return scrollInfo.release();
}
+WebTransformationMatrix CCLayerTreeHostImpl::implTransform() const
+{
+ WebTransformationMatrix transform;
+ transform.scale(m_pageScaleDelta);
+
+ // If the pinch state is applied in the impl, then push it to the
+ // impl transform, otherwise the scale is handled by WebCore.
+ if (CCSettings::pageScalePinchZoomEnabled()) {
+ transform.scale(m_pageScaleFactor);
+ transform.translate(-m_pinchZoomViewport.scrollDelta().x(),
+ -m_pinchZoomViewport.scrollDelta().y());
+ }
+
+ return transform;
+}
+
void CCLayerTreeHostImpl::setFullRootLayerDamage()
{
if (m_rootLayerImpl) {
@@ -1197,7 +1291,7 @@
IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
- setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_pageScale);
+ setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_pageScaleFactor);
IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
nextScroll.scale(1 / m_pageScaleDelta);
m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal);
« no previous file with comments | « cc/CCLayerTreeHostImpl.h ('k') | cc/CCLayerTreeHostImplTest.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698