cc/layer_tree_host_impl.cc - Issue 11367080: cc: Remove all remaining use of WebCore Rect/Point/Size types from the compositor.

Unified Diff: cc/layer_tree_host_impl.cc

Issue 11367080: cc: Remove all remaining use of WebCore Rect/Point/Size types from the compositor. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: rebase Created 8 years, 1 month 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

Index: cc/layer_tree_host_impl.cc

diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc

index 73568ffc3980770b8d8d75d02428522e7cf3552d..2f5ee5ca2fe4953a97a3a188c7e7fe3e190e458d 100644

--- a/cc/layer_tree_host_impl.cc

+++ b/cc/layer_tree_host_impl.cc

@@ -14,6 +14,7 @@

#include "cc/delay_based_time_source.h"

#include "cc/font_atlas.h"

#include "cc/frame_rate_counter.h"

+#include "cc/geometry.h"

#include "cc/gl_renderer.h"

#include "cc/heads_up_display_layer_impl.h"

#include "cc/layer_iterator.h"

@@ -32,6 +33,7 @@

#include "cc/software_renderer.h"

#include "cc/texture_uploader.h"

#include "ui/gfx/size_conversions.h"

+#include "ui/gfx/vector2d_conversions.h"

#include <algorithm>

using WebKit::WebTransformationMatrix;

@@ -101,12 +103,12 @@ gfx::RectF PinchZoomViewport::bounds() const

scaledViewportSize = scaledViewportSize.Scale(1 / totalPageScaleFactor());

gfx::RectF bounds(gfx::PointF(), scaledViewportSize);

- bounds.set_origin(m_pinchViewportScrollDelta);

+ bounds.Offset(m_pinchViewportScrollDelta);

return bounds;

}

-FloatSize PinchZoomViewport::applyScroll(const gfx::Vector2dF& delta)

+gfx::Vector2dF PinchZoomViewport::applyScroll(const gfx::Vector2dF& delta)

{

gfx::Vector2dF overflow;

gfx::RectF pinchedBounds = bounds();

@@ -131,9 +133,9 @@ FloatSize PinchZoomViewport::applyScroll(const gfx::Vector2dF& delta)

overflow.set_y(pinchedBounds.bottom() - m_layoutViewportSize.height());

pinchedBounds.Offset(0, m_layoutViewportSize.height() - pinchedBounds.bottom());

}

- m_pinchViewportScrollDelta = cc::FloatPoint(pinchedBounds.origin());

+ m_pinchViewportScrollDelta = pinchedBounds.OffsetFromOrigin();

- return cc::FloatSize(overflow);

+ return overflow;

}

WebTransformationMatrix PinchZoomViewport::implTransform() const

@@ -249,7 +251,7 @@ void LayerTreeHostImpl::commitComplete()

TRACE_EVENT0("cc", "LayerTreeHostImpl::commitComplete");

// Recompute max scroll position; must be after layer content bounds are

// updated.

- updateMaxScrollPosition();

+ updateMaxScrollOffset();

m_client->sendManagedMemoryStats();

}

@@ -290,26 +292,26 @@ void LayerTreeHostImpl::animate(base::TimeTicks monotonicTime, base::Time wallCl

animateScrollbars(monotonicTime);

}

-void LayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)

+void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)

{

if (!m_rootScrollLayerImpl)

return;

- IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());

- scrollTotal.scale(m_pinchZoomViewport.pageScaleDelta());

+ gfx::Vector2dF scrollTotal = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();

+ scrollTotal.Scale(m_pinchZoomViewport.pageScaleDelta());

float scaleTotal = m_pinchZoomViewport.totalPageScaleFactor();

gfx::Size scaledContentSize = gfx::ToFlooredSize(contentSize().Scale(m_pinchZoomViewport.pageScaleDelta()));

double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();

- m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, scaleTotal, cc::IntSize(m_deviceViewportSize), scaledContentSize, startTimeSeconds);

+ m_pageScaleAnimation = PageScaleAnimation::create(gfx::ToFlooredVector2d(scrollTotal), scaleTotal, m_deviceViewportSize, scaledContentSize, startTimeSeconds);

if (anchorPoint) {

- IntSize windowAnchor(targetPosition);

- windowAnchor.scale(scaleTotal / pageScale);

+ gfx::Vector2dF windowAnchor = targetOffset;

+ windowAnchor.Scale(scaleTotal / pageScale);

windowAnchor -= scrollTotal;

- m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration.InSecondsF());

+ m_pageScaleAnimation->zoomWithAnchor(gfx::ToFlooredVector2d(windowAnchor), pageScale, duration.InSecondsF());

} else

- m_pageScaleAnimation->zoomTo(targetPosition, pageScale, duration.InSecondsF());

+ m_pageScaleAnimation->zoomTo(targetOffset, pageScale, duration.InSecondsF());

m_client->setNeedsRedrawOnImplThread();

m_client->setNeedsCommitOnImplThread();

@@ -890,9 +892,9 @@ void LayerTreeHostImpl::setViewportSize(const gfx::Size& layoutViewportSize, con

m_layoutViewportSize = layoutViewportSize;

m_deviceViewportSize = deviceViewportSize;

- m_pinchZoomViewport.setLayoutViewportSize(FloatSize(layoutViewportSize));

+ m_pinchZoomViewport.setLayoutViewportSize(layoutViewportSize);

- updateMaxScrollPosition();

+ updateMaxScrollOffset();

if (m_renderer)

m_renderer->viewportChanged();

@@ -907,8 +909,8 @@ static void adjustScrollsForPageScaleChange(LayerImpl* layerImpl, float pageScal

if (layerImpl->scrollable()) {

// We need to convert impl-side scroll deltas to pageScale space.

- FloatSize scrollDelta = layerImpl->scrollDelta();

- scrollDelta.scale(pageScaleChange);

+ gfx::Vector2dF scrollDelta = layerImpl->scrollDelta();

+ scrollDelta.Scale(pageScaleChange);

layerImpl->setScrollDelta(scrollDelta);

}

@@ -922,7 +924,7 @@ void LayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor)

return;

m_deviceScaleFactor = deviceScaleFactor;

- updateMaxScrollPosition();

+ updateMaxScrollOffset();

}

float LayerTreeHostImpl::pageScaleFactor() const

@@ -952,10 +954,10 @@ void LayerTreeHostImpl::setPageScaleDelta(float delta)

{

m_pinchZoomViewport.setPageScaleDelta(delta);

- updateMaxScrollPosition();

+ updateMaxScrollOffset();

}

-void LayerTreeHostImpl::updateMaxScrollPosition()

+void LayerTreeHostImpl::updateMaxScrollOffset()

{

if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size())

return;

@@ -981,14 +983,14 @@ void LayerTreeHostImpl::updateMaxScrollPosition()

viewBounds = viewBounds.Scale(1 / m_pinchZoomViewport.pageScaleDelta());

}

- IntSize maxScroll = cc::IntSize(contentBounds) - expandedIntSize(cc::FloatSize(viewBounds));

- maxScroll.scale(1 / m_deviceScaleFactor);

+ gfx::Vector2dF maxScroll = BottomRight(gfx::Rect(contentBounds)) - BottomRight(gfx::RectF(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();

+ maxScroll = ClampFromBelow(maxScroll, gfx::Vector2dF());

- m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll);

+ m_rootScrollLayerImpl->setMaxScrollOffset(gfx::ToFlooredVector2d(maxScroll));

}

void LayerTreeHostImpl::setNeedsRedraw()

@@ -1017,7 +1019,7 @@ bool LayerTreeHostImpl::ensureRenderSurfaceLayerList()

return m_renderSurfaceLayerList.size();

}

-InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(const gfx::Point& viewportPoint, InputHandlerClient::ScrollInputType type)

+InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(gfx::Point viewportPoint, InputHandlerClient::ScrollInputType type)

{

TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");

@@ -1070,7 +1072,7 @@ InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(const gfx::Point

return ScrollIgnored;

}

-static FloatSize scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport, LayerImpl& layerImpl, float scaleFromViewportToScreenSpace, const gfx::PointF& viewportPoint, const FloatSize& viewportDelta)

+static gfx::Vector2dF scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport, LayerImpl& layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta)

{

// Layers with non-invertible screen space transforms should not have passed the scroll hit

// test in the first place.

@@ -1079,8 +1081,8 @@ static FloatSize scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport,

gfx::PointF screenSpacePoint = viewportPoint.Scale(scaleFromViewportToScreenSpace);

- FloatSize screenSpaceDelta = viewportDelta;

- screenSpaceDelta.scale(scaleFromViewportToScreenSpace, scaleFromViewportToScreenSpace);

+ gfx::Vector2dF screenSpaceDelta = viewportDelta;

+ screenSpaceDelta.Scale(scaleFromViewportToScreenSpace);

// First project the scroll start and end points to local layer space to find the scroll delta

// in layer coordinates.

@@ -1093,7 +1095,7 @@ static FloatSize scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport,

DCHECK(!startClipped);

DCHECK(!endClipped);

if (startClipped || endClipped)

- return FloatSize();

+ return gfx::Vector2dF();

// localStartPoint and localEndPoint are in content space but we want to move them to layer space for scrolling.

float widthScale = 1 / layerImpl.contentsScaleX();

@@ -1102,8 +1104,8 @@ static FloatSize scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport,

localEndPoint = localEndPoint.Scale(widthScale, heightScale);

// Apply the scroll delta.

- FloatSize previousDelta(layerImpl.scrollDelta());

- FloatSize unscrolled = layerImpl.scrollBy(cc::FloatSize(localEndPoint - localStartPoint));

+ gfx::Vector2dF previousDelta = layerImpl.scrollDelta();

+ gfx::Vector2dF unscrolled = layerImpl.scrollBy(localEndPoint - localStartPoint);

if (viewport)

viewport->applyScroll(unscrolled);

@@ -1116,32 +1118,32 @@ static FloatSize scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport,

gfx::PointF actualScreenSpaceEndPoint = MathUtil::mapPoint(layerImpl.screenSpaceTransform(), actualLocalContentEndPoint, endClipped);

DCHECK(!endClipped);

if (endClipped)

- return FloatSize();

+ return gfx::Vector2dF();

gfx::PointF actualViewportEndPoint = actualScreenSpaceEndPoint.Scale(1 / scaleFromViewportToScreenSpace);

- return cc::FloatSize(actualViewportEndPoint - viewportPoint);

+ return actualViewportEndPoint - viewportPoint;

}

-static FloatSize scrollLayerWithLocalDelta(LayerImpl& layerImpl, const FloatSize& localDelta)

+static gfx::Vector2dF scrollLayerWithLocalDelta(LayerImpl& layerImpl, gfx::Vector2dF localDelta)

{

- FloatSize previousDelta(layerImpl.scrollDelta());

+ gfx::Vector2dF previousDelta(layerImpl.scrollDelta());

layerImpl.scrollBy(localDelta);

return layerImpl.scrollDelta() - previousDelta;

}

-void LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint, const IntSize& scrollDelta)

+void LayerTreeHostImpl::scrollBy(gfx::Point viewportPoint, gfx::Vector2d scrollDelta)

{

TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBy");

if (!m_currentlyScrollingLayerImpl)

return;

- FloatSize pendingDelta(scrollDelta);

+ gfx::Vector2dF pendingDelta = scrollDelta;

for (LayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl; layerImpl = layerImpl->parent()) {

if (!layerImpl->scrollable())

continue;

PinchZoomViewport* viewport = layerImpl == m_rootScrollLayerImpl ? &m_pinchZoomViewport : 0;

- FloatSize appliedDelta;

+ gfx::Vector2dF appliedDelta;

if (m_scrollDeltaIsInViewportSpace) {

float scaleFromViewportToScreenSpace = m_deviceScaleFactor;

appliedDelta = scrollLayerWithViewportSpaceDelta(viewport, *layerImpl, scaleFromViewportToScreenSpace, viewportPoint, pendingDelta);

@@ -1150,27 +1152,27 @@ void LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint, const IntSize&

// If the layer wasn't able to move, try the next one in the hierarchy.

float moveThresholdSquared = 0.1f * 0.1f;

- if (appliedDelta.diagonalLengthSquared() < moveThresholdSquared)

+ if (appliedDelta.LengthSquared() < moveThresholdSquared)

continue;

// If the applied delta is within 45 degrees of the input delta, bail out to make it easier

// to scroll just one layer in one direction without affecting any of its parents.

float angleThreshold = 45;

if (MathUtil::smallestAngleBetweenVectors(appliedDelta, pendingDelta) < angleThreshold) {

- pendingDelta = FloatSize();

+ pendingDelta = gfx::Vector2d();

break;

}

// Allow further movement only on an axis perpendicular to the direction in which the layer

// moved.

- FloatSize perpendicularAxis(-appliedDelta.height(), appliedDelta.width());

+ gfx::Vector2dF perpendicularAxis(-appliedDelta.y(), appliedDelta.x());

pendingDelta = MathUtil::projectVector(pendingDelta, perpendicularAxis);

- if (flooredIntSize(pendingDelta).isZero())

+ if (gfx::ToFlooredVector2d(pendingDelta).IsZero())

break;

}

- if (!scrollDelta.isZero() && flooredIntSize(pendingDelta).isEmpty()) {

+ if (!scrollDelta.IsZero() && gfx::ToFlooredVector2d(pendingDelta).IsZero()) {

m_client->setNeedsCommitOnImplThread();

m_client->setNeedsRedrawOnImplThread();

}

@@ -1190,42 +1192,40 @@ void LayerTreeHostImpl::scrollEnd()

void LayerTreeHostImpl::pinchGestureBegin()

{

m_pinchGestureActive = true;

- m_previousPinchAnchor = IntPoint();

+ m_previousPinchAnchor = gfx::Point();

if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationController())

m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureBegin();

}

-void LayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta,

- const IntPoint& anchor)

+void LayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta, gfx::Point anchor)

{

TRACE_EVENT0("cc", "LayerTreeHostImpl::pinchGestureUpdate");

if (!m_rootScrollLayerImpl)

return;

- if (m_previousPinchAnchor == IntPoint::zero())

+ if (m_previousPinchAnchor == gfx::Point())

m_previousPinchAnchor = anchor;

// Keep the center-of-pinch anchor specified by (x, y) in a stable

// position over the course of the magnify.

float pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();

- FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / pageScaleDelta,

- m_previousPinchAnchor.y() / pageScaleDelta);

+ gfx::PointF previousScaleAnchor = m_previousPinchAnchor.Scale(1 / pageScaleDelta);

setPageScaleDelta(pageScaleDelta * magnifyDelta);

pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();

- FloatPoint newScaleAnchor(anchor.x() / pageScaleDelta, anchor.y() / pageScaleDelta);

- FloatSize move = previousScaleAnchor - newScaleAnchor;

+ gfx::PointF newScaleAnchor = anchor.Scale(1 / pageScaleDelta);

+ gfx::Vector2dF move = previousScaleAnchor - newScaleAnchor;

m_previousPinchAnchor = anchor;

if (Settings::pageScalePinchZoomEnabled()) {

// Compute the application of the delta with respect to the current page zoom of the page.

- move.scale(1 / (m_pinchZoomViewport.pageScaleFactor() * m_deviceScaleFactor));

+ move.Scale(1 / (m_pinchZoomViewport.pageScaleFactor() * m_deviceScaleFactor));

}

- FloatSize scrollOverflow = Settings::pageScalePinchZoomEnabled() ? m_pinchZoomViewport.applyScroll(move) : move;

- m_rootScrollLayerImpl->scrollBy(roundedIntSize(scrollOverflow));

+ gfx::Vector2dF scrollOverflow = Settings::pageScalePinchZoomEnabled() ? m_pinchZoomViewport.applyScroll(move) : move;

+ m_rootScrollLayerImpl->scrollBy(scrollOverflow);

if (m_rootScrollLayerImpl->scrollbarAnimationController())

m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUpdate();

@@ -1247,9 +1247,9 @@ void LayerTreeHostImpl::pinchGestureEnd()

void LayerTreeHostImpl::computeDoubleTapZoomDeltas(ScrollAndScaleSet* scrollInfo)

{

float pageScale = m_pageScaleAnimation->finalPageScale();

- IntSize scrollOffset = m_pageScaleAnimation->finalScrollOffset();

- scrollOffset.scale(m_pinchZoomViewport.pageScaleFactor() / pageScale);

- makeScrollAndScaleSet(scrollInfo, scrollOffset, pageScale);

+ gfx::Vector2dF scrollOffset = m_pageScaleAnimation->finalScrollOffset();

+ scrollOffset.Scale(m_pinchZoomViewport.pageScaleFactor() / pageScale);

+ makeScrollAndScaleSet(scrollInfo, gfx::ToRoundedVector2d(scrollOffset), pageScale);

}

void LayerTreeHostImpl::computePinchZoomDeltas(ScrollAndScaleSet* scrollInfo)

@@ -1266,31 +1266,32 @@ void LayerTreeHostImpl::computePinchZoomDeltas(ScrollAndScaleSet* scrollInfo)

// Compute where the scroll offset/page scale would be if fully pinch-zoomed

// out from the anchor point.

- IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());

- scrollBegin.scale(m_pinchZoomViewport.pageScaleDelta());

+ gfx::Vector2dF scrollBegin = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();

+ scrollBegin.Scale(m_pinchZoomViewport.pageScaleDelta());

float scaleBegin = m_pinchZoomViewport.totalPageScaleFactor();

float pageScaleDeltaToSend = m_pinchZoomViewport.minPageScaleFactor() / m_pinchZoomViewport.pageScaleFactor();

gfx::SizeF scaledContentsSize = contentSize().Scale(pageScaleDeltaToSend);

- FloatSize anchor = toSize(m_previousPinchAnchor);

- FloatSize scrollEnd = scrollBegin + anchor;

- scrollEnd.scale(m_pinchZoomViewport.minPageScaleFactor() / scaleBegin);

- scrollEnd -= anchor;

- scrollEnd = scrollEnd.shrunkTo(roundedIntSize(cc::FloatSize(scaledContentsSize) - cc::IntSize(m_deviceViewportSize))).expandedTo(FloatSize(0, 0));

- scrollEnd.scale(1 / pageScaleDeltaToSend);

- scrollEnd.scale(m_deviceScaleFactor);

+ gfx::Vector2d anchorOffset = m_previousPinchAnchor.OffsetFromOrigin();

+ gfx::Vector2dF scrollEnd = scrollBegin + anchorOffset;

+ scrollEnd.Scale(m_pinchZoomViewport.minPageScaleFactor() / scaleBegin);

+ scrollEnd -= anchorOffset;

+ scrollEnd = ClampFromAbove(scrollEnd, BottomRight(gfx::RectF(scaledContentsSize)) - BottomRight(gfx::Rect(m_deviceViewportSize)));

+ scrollEnd = ClampFromBelow(scrollEnd, gfx::Vector2d());

+ scrollEnd.Scale(1 / pageScaleDeltaToSend);

+ scrollEnd.Scale(m_deviceScaleFactor);

- makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_pinchZoomViewport.minPageScaleFactor());

+ makeScrollAndScaleSet(scrollInfo, gfx::ToRoundedVector2d(scrollEnd), m_pinchZoomViewport.minPageScaleFactor());

}

-void LayerTreeHostImpl::makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale)

+void LayerTreeHostImpl::makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, gfx::Vector2d scrollOffset, float pageScale)

{

if (!m_rootScrollLayerImpl)

return;

LayerTreeHostCommon::ScrollUpdateInfo scroll;

scroll.layerId = m_rootScrollLayerImpl->id();

- scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosition());

+ scroll.scrollDelta = scrollOffset - m_rootScrollLayerImpl->scrollOffset();

scrollInfo->scrolls.push_back(scroll);

m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);

scrollInfo->pageScaleDelta = pageScale / m_pinchZoomViewport.pageScaleFactor();

@@ -1302,8 +1303,8 @@ static void collectScrollDeltas(ScrollAndScaleSet* scrollInfo, LayerImpl* layerI

if (!layerImpl)

return;

- if (!layerImpl->scrollDelta().isZero()) {

- IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta());

+ if (!layerImpl->scrollDelta().IsZero()) {

+ gfx::Vector2d scrollDelta = gfx::ToFlooredVector2d(layerImpl->scrollDelta());

LayerTreeHostCommon::ScrollUpdateInfo scroll;

scroll.layerId = layerImpl->id();

scroll.scrollDelta = scrollDelta;

@@ -1360,11 +1361,11 @@ void LayerTreeHostImpl::animatePageScale(base::TimeTicks time)

return;

double monotonicTime = (time - base::TimeTicks()).InSecondsF();

- IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());

+ gfx::Vector2dF scrollTotal = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();

setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_pinchZoomViewport.pageScaleFactor());

- IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);

- nextScroll.scale(1 / m_pinchZoomViewport.pageScaleDelta());

+ gfx::Vector2dF nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);

+ nextScroll.Scale(1 / m_pinchZoomViewport.pageScaleDelta());

m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal);

m_client->setNeedsRedrawOnImplThread();

« no previous file with comments | « cc/layer_tree_host_impl.h ('k') | cc/layer_tree_host_impl_unittest.cc » ('j') | no next file with comments »