OLD | NEW |
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 1 // Copyright 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "config.h" | 5 #include "config.h" |
6 | 6 |
7 #include "CCLayerTreeHostImpl.h" | 7 #include "CCLayerTreeHostImpl.h" |
8 | 8 |
9 #include "CCAppendQuadsData.h" | 9 #include "CCAppendQuadsData.h" |
10 #include "CCDamageTracker.h" | 10 #include "CCDamageTracker.h" |
(...skipping 30 matching lines...) Expand all Loading... |
41 return; | 41 return; |
42 } | 42 } |
43 | 43 |
44 TRACE_EVENT_ASYNC_END0("webkit", "CCLayerTreeHostImpl::setVisible", id); | 44 TRACE_EVENT_ASYNC_END0("webkit", "CCLayerTreeHostImpl::setVisible", id); |
45 } | 45 } |
46 | 46 |
47 } // namespace | 47 } // namespace |
48 | 48 |
49 namespace cc { | 49 namespace cc { |
50 | 50 |
| 51 FloatRect CCPinchZoomViewport::bounds() const |
| 52 { |
| 53 FloatSize scaledBounds = m_unpinchedBounds; |
| 54 if (m_pageScaleFactor > 1) |
| 55 scaledBounds.scale(1 / m_pageScaleFactor); |
| 56 |
| 57 FloatRect bounds; |
| 58 bounds.setSize(scaledBounds); |
| 59 bounds.setLocation(m_pinchViewportScrollDelta); |
| 60 |
| 61 return bounds; |
| 62 } |
| 63 |
| 64 FloatSize CCPinchZoomViewport::applyScroll(FloatSize& delta) |
| 65 { |
| 66 FloatSize overflow; |
| 67 FloatRect pinchedBounds = bounds(); |
| 68 |
| 69 pinchedBounds.move(delta); |
| 70 if (pinchedBounds.x() < 0) { |
| 71 pinchedBounds.setX(0); |
| 72 overflow.setWidth(pinchedBounds.x()); |
| 73 } |
| 74 |
| 75 if (pinchedBounds.y() < 0) { |
| 76 pinchedBounds.setY(0); |
| 77 overflow.setHeight(pinchedBounds.y()); |
| 78 } |
| 79 |
| 80 if (pinchedBounds.maxX() > m_unpinchedBounds.width()) { |
| 81 pinchedBounds.move(m_unpinchedBounds.width() - pinchedBounds.maxX(), 0); |
| 82 overflow.setWidth(pinchedBounds.maxX() - m_unpinchedBounds.width()); |
| 83 } |
| 84 |
| 85 if (pinchedBounds.maxY() > m_unpinchedBounds.height()) { |
| 86 pinchedBounds.move(0, m_unpinchedBounds.height() - pinchedBounds.maxY())
; |
| 87 overflow.setHeight(pinchedBounds.maxY() - m_unpinchedBounds.height()); |
| 88 } |
| 89 m_pinchViewportScrollDelta = pinchedBounds.location(); |
| 90 |
| 91 return overflow; |
| 92 } |
| 93 |
51 class CCLayerTreeHostImplTimeSourceAdapter : public CCTimeSourceClient { | 94 class CCLayerTreeHostImplTimeSourceAdapter : public CCTimeSourceClient { |
52 WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImplTimeSourceAdapter); | 95 WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImplTimeSourceAdapter); |
53 public: | 96 public: |
54 static PassOwnPtr<CCLayerTreeHostImplTimeSourceAdapter> create(CCLayerTreeHo
stImpl* layerTreeHostImpl, PassRefPtr<CCDelayBasedTimeSource> timeSource) | 97 static PassOwnPtr<CCLayerTreeHostImplTimeSourceAdapter> create(CCLayerTreeHo
stImpl* layerTreeHostImpl, PassRefPtr<CCDelayBasedTimeSource> timeSource) |
55 { | 98 { |
56 return adoptPtr(new CCLayerTreeHostImplTimeSourceAdapter(layerTreeHostIm
pl, timeSource)); | 99 return adoptPtr(new CCLayerTreeHostImplTimeSourceAdapter(layerTreeHostIm
pl, timeSource)); |
57 } | 100 } |
58 virtual ~CCLayerTreeHostImplTimeSourceAdapter() | 101 virtual ~CCLayerTreeHostImplTimeSourceAdapter() |
59 { | 102 { |
60 m_timeSource->setClient(0); | 103 m_timeSource->setClient(0); |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
108 , m_rootScrollLayerImpl(0) | 151 , m_rootScrollLayerImpl(0) |
109 , m_currentlyScrollingLayerImpl(0) | 152 , m_currentlyScrollingLayerImpl(0) |
110 , m_hudLayerImpl(0) | 153 , m_hudLayerImpl(0) |
111 , m_scrollingLayerIdFromPreviousTree(-1) | 154 , m_scrollingLayerIdFromPreviousTree(-1) |
112 , m_scrollDeltaIsInScreenSpace(false) | 155 , m_scrollDeltaIsInScreenSpace(false) |
113 , m_settings(settings) | 156 , m_settings(settings) |
114 , m_deviceScaleFactor(1) | 157 , m_deviceScaleFactor(1) |
115 , m_visible(true) | 158 , m_visible(true) |
116 , m_contentsTexturesPurged(false) | 159 , m_contentsTexturesPurged(false) |
117 , m_memoryAllocationLimitBytes(CCPrioritizedTextureManager::defaultMemoryAll
ocationLimit()) | 160 , m_memoryAllocationLimitBytes(CCPrioritizedTextureManager::defaultMemoryAll
ocationLimit()) |
118 , m_pageScale(1) | 161 , m_pageScaleFactor(1) |
119 , m_pageScaleDelta(1) | 162 , m_pageScaleDelta(1) |
120 , m_sentPageScaleDelta(1) | 163 , m_sentPageScaleDelta(1) |
121 , m_minPageScale(0) | 164 , m_minPageScaleFactor(0) |
122 , m_maxPageScale(0) | 165 , m_maxPageScaleFactor(0) |
123 , m_backgroundColor(0) | 166 , m_backgroundColor(0) |
124 , m_hasTransparentBackground(false) | 167 , m_hasTransparentBackground(false) |
125 , m_needsAnimateLayers(false) | 168 , m_needsAnimateLayers(false) |
126 , m_pinchGestureActive(false) | 169 , m_pinchGestureActive(false) |
| 170 , m_applyPinchZoomInImpl(false) |
127 , m_fpsCounter(CCFrameRateCounter::create()) | 171 , m_fpsCounter(CCFrameRateCounter::create()) |
128 , m_debugRectHistory(CCDebugRectHistory::create()) | 172 , m_debugRectHistory(CCDebugRectHistory::create()) |
129 { | 173 { |
130 ASSERT(CCProxy::isImplThread()); | 174 ASSERT(CCProxy::isImplThread()); |
131 didVisibilityChange(this, m_visible); | 175 didVisibilityChange(this, m_visible); |
| 176 |
| 177 m_applyPinchZoomInImpl = CCSettings::pageScalePinchZoomEnabled(); |
132 } | 178 } |
133 | 179 |
134 CCLayerTreeHostImpl::~CCLayerTreeHostImpl() | 180 CCLayerTreeHostImpl::~CCLayerTreeHostImpl() |
135 { | 181 { |
136 ASSERT(CCProxy::isImplThread()); | 182 ASSERT(CCProxy::isImplThread()); |
137 TRACE_EVENT0("cc", "CCLayerTreeHostImpl::~CCLayerTreeHostImpl()"); | 183 TRACE_EVENT0("cc", "CCLayerTreeHostImpl::~CCLayerTreeHostImpl()"); |
138 | 184 |
139 if (m_rootLayerImpl) | 185 if (m_rootLayerImpl) |
140 clearRenderSurfaces(); | 186 clearRenderSurfaces(); |
141 } | 187 } |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
189 animateScrollbars(monotonicTime); | 235 animateScrollbars(monotonicTime); |
190 } | 236 } |
191 | 237 |
192 void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition,
bool anchorPoint, float pageScale, double startTime, double duration) | 238 void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition,
bool anchorPoint, float pageScale, double startTime, double duration) |
193 { | 239 { |
194 if (!m_rootScrollLayerImpl) | 240 if (!m_rootScrollLayerImpl) |
195 return; | 241 return; |
196 | 242 |
197 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition()
+ m_rootScrollLayerImpl->scrollDelta()); | 243 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition()
+ m_rootScrollLayerImpl->scrollDelta()); |
198 scrollTotal.scale(m_pageScaleDelta); | 244 scrollTotal.scale(m_pageScaleDelta); |
199 float scaleTotal = m_pageScale * m_pageScaleDelta; | 245 float scaleTotal = m_pageScaleFactor * m_pageScaleDelta; |
200 IntSize scaledContentSize = contentSize(); | 246 IntSize scaledContentSize = contentSize(); |
201 scaledContentSize.scale(m_pageScaleDelta); | 247 scaledContentSize.scale(m_pageScaleDelta); |
202 | 248 |
203 m_pageScaleAnimation = CCPageScaleAnimation::create(scrollTotal, scaleTotal,
m_deviceViewportSize, scaledContentSize, startTime); | 249 m_pageScaleAnimation = CCPageScaleAnimation::create(scrollTotal, scaleTotal,
m_deviceViewportSize, scaledContentSize, startTime); |
204 | 250 |
205 if (anchorPoint) { | 251 if (anchorPoint) { |
206 IntSize windowAnchor(targetPosition); | 252 IntSize windowAnchor(targetPosition); |
207 windowAnchor.scale(scaleTotal / pageScale); | 253 windowAnchor.scale(scaleTotal / pageScale); |
208 windowAnchor -= scrollTotal; | 254 windowAnchor -= scrollTotal; |
209 m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration); | 255 m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration); |
(...skipping 16 matching lines...) Expand all Loading... |
226 // damage rect. The root damage rect is then used to scissor each surface. | 272 // damage rect. The root damage rect is then used to scissor each surface. |
227 | 273 |
228 for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0
; --surfaceIndex) { | 274 for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0
; --surfaceIndex) { |
229 CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex]; | 275 CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex]; |
230 CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface(); | 276 CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface(); |
231 ASSERT(renderSurface); | 277 ASSERT(renderSurface); |
232 renderSurface->damageTracker()->updateDamageTrackingState(renderSurface-
>layerList(), renderSurfaceLayer->id(), renderSurface->surfacePropertyChangedOnl
yFromDescendant(), renderSurface->contentRect(), renderSurfaceLayer->maskLayer()
, renderSurfaceLayer->filters()); | 278 renderSurface->damageTracker()->updateDamageTrackingState(renderSurface-
>layerList(), renderSurfaceLayer->id(), renderSurface->surfacePropertyChangedOnl
yFromDescendant(), renderSurface->contentRect(), renderSurfaceLayer->maskLayer()
, renderSurfaceLayer->filters()); |
233 } | 279 } |
234 } | 280 } |
235 | 281 |
| 282 void CCLayerTreeHostImpl::updateRootScrollLayerImplTransform() |
| 283 { |
| 284 if (m_rootScrollLayerImpl) { |
| 285 m_rootScrollLayerImpl->setImplTransform(implTransform()); |
| 286 } |
| 287 } |
| 288 |
236 void CCLayerTreeHostImpl::calculateRenderSurfaceLayerList(CCLayerList& renderSur
faceLayerList) | 289 void CCLayerTreeHostImpl::calculateRenderSurfaceLayerList(CCLayerList& renderSur
faceLayerList) |
237 { | 290 { |
238 ASSERT(renderSurfaceLayerList.isEmpty()); | 291 ASSERT(renderSurfaceLayerList.isEmpty()); |
239 ASSERT(m_rootLayerImpl); | 292 ASSERT(m_rootLayerImpl); |
240 ASSERT(m_renderer); // For maxTextureSize. | 293 ASSERT(m_renderer); // For maxTextureSize. |
241 | 294 |
242 { | 295 { |
| 296 updateRootScrollLayerImplTransform(); |
| 297 |
243 TRACE_EVENT0("cc", "CCLayerTreeHostImpl::calcDrawEtc"); | 298 TRACE_EVENT0("cc", "CCLayerTreeHostImpl::calcDrawEtc"); |
244 CCLayerTreeHostCommon::calculateDrawTransforms(m_rootLayerImpl.get(), de
viceViewportSize(), m_deviceScaleFactor, &m_layerSorter, rendererCapabilities().
maxTextureSize, renderSurfaceLayerList); | 299 CCLayerTreeHostCommon::calculateDrawTransforms(m_rootLayerImpl.get(), de
viceViewportSize(), m_deviceScaleFactor, &m_layerSorter, rendererCapabilities().
maxTextureSize, renderSurfaceLayerList); |
245 CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList); | 300 CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList); |
246 | 301 |
247 trackDamageForAllSurfaces(m_rootLayerImpl.get(), renderSurfaceLayerList)
; | 302 trackDamageForAllSurfaces(m_rootLayerImpl.get(), renderSurfaceLayerList)
; |
248 } | 303 } |
249 } | 304 } |
250 | 305 |
251 void CCLayerTreeHostImpl::FrameData::appendRenderPass(PassOwnPtr<CCRenderPass> r
enderPass) | 306 void CCLayerTreeHostImpl::FrameData::appendRenderPass(PassOwnPtr<CCRenderPass> r
enderPass) |
252 { | 307 { |
(...skipping 507 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
760 } | 815 } |
761 | 816 |
762 void CCLayerTreeHostImpl::setViewportSize(const IntSize& layoutViewportSize, con
st IntSize& deviceViewportSize) | 817 void CCLayerTreeHostImpl::setViewportSize(const IntSize& layoutViewportSize, con
st IntSize& deviceViewportSize) |
763 { | 818 { |
764 if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_de
viceViewportSize) | 819 if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_de
viceViewportSize) |
765 return; | 820 return; |
766 | 821 |
767 m_layoutViewportSize = layoutViewportSize; | 822 m_layoutViewportSize = layoutViewportSize; |
768 m_deviceViewportSize = deviceViewportSize; | 823 m_deviceViewportSize = deviceViewportSize; |
769 | 824 |
| 825 m_pinchZoomViewport.setUnpinchedBounds(FloatSize(layoutViewportSize)); |
| 826 |
770 updateMaxScrollPosition(); | 827 updateMaxScrollPosition(); |
771 | 828 |
772 if (m_renderer) | 829 if (m_renderer) |
773 m_renderer->viewportChanged(); | 830 m_renderer->viewportChanged(); |
774 | 831 |
775 m_client->onCanDrawStateChanged(canDraw()); | 832 m_client->onCanDrawStateChanged(canDraw()); |
776 } | 833 } |
777 | 834 |
778 static void adjustScrollsForPageScaleChange(CCLayerImpl* layerImpl, float pageSc
aleChange) | 835 static void adjustScrollsForPageScaleChange(CCLayerImpl* layerImpl, float pageSc
aleChange) |
779 { | 836 { |
(...skipping 14 matching lines...) Expand all Loading... |
794 void CCLayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor) | 851 void CCLayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor) |
795 { | 852 { |
796 if (deviceScaleFactor == m_deviceScaleFactor) | 853 if (deviceScaleFactor == m_deviceScaleFactor) |
797 return; | 854 return; |
798 m_deviceScaleFactor = deviceScaleFactor; | 855 m_deviceScaleFactor = deviceScaleFactor; |
799 | 856 |
800 updateMaxScrollPosition(); | 857 updateMaxScrollPosition(); |
801 } | 858 } |
802 | 859 |
803 | 860 |
804 void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScale, float min
PageScale, float maxPageScale) | 861 void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, flo
at minPageScaleFactor, float maxPageScaleFactor) |
805 { | 862 { |
806 if (!pageScale) | 863 if (!pageScaleFactor) |
807 return; | 864 return; |
808 | 865 |
809 if (m_sentPageScaleDelta == 1 && pageScale == m_pageScale && minPageScale ==
m_minPageScale && maxPageScale == m_maxPageScale) | 866 if (m_sentPageScaleDelta == 1 && pageScaleFactor == m_pageScaleFactor && min
PageScaleFactor == m_minPageScaleFactor && maxPageScaleFactor == m_maxPageScaleF
actor) |
810 return; | 867 return; |
811 | 868 |
812 m_minPageScale = minPageScale; | 869 m_minPageScaleFactor = minPageScaleFactor; |
813 m_maxPageScale = maxPageScale; | 870 m_maxPageScaleFactor = maxPageScaleFactor; |
814 | 871 |
815 float pageScaleChange = pageScale / m_pageScale; | 872 float pageScaleChange = pageScaleFactor / m_pageScaleFactor; |
816 m_pageScale = pageScale; | 873 m_pageScaleFactor = pageScaleFactor; |
817 | 874 |
818 if (pageScaleChange != 1) | 875 if (!m_applyPinchZoomInImpl) { |
819 adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange); | 876 if (pageScaleChange != 1) |
| 877 adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChan
ge); |
| 878 } |
820 | 879 |
821 // Clamp delta to limits and refresh display matrix. | 880 // Clamp delta to limits and refresh display matrix. |
822 setPageScaleDelta(m_pageScaleDelta / m_sentPageScaleDelta); | 881 setPageScaleDelta(m_pageScaleDelta / m_sentPageScaleDelta); |
823 m_sentPageScaleDelta = 1; | 882 m_sentPageScaleDelta = 1; |
824 if (m_rootScrollLayerImpl) | |
825 m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta); | |
826 } | 883 } |
827 | 884 |
828 void CCLayerTreeHostImpl::setPageScaleDelta(float delta) | 885 void CCLayerTreeHostImpl::setPageScaleDelta(float delta) |
829 { | 886 { |
830 // Clamp to the current min/max limits. | 887 // Clamp to the current min/max limits. |
831 float finalMagnifyScale = m_pageScale * delta; | 888 float finalMagnifyScale = m_pageScaleFactor * delta; |
832 if (m_minPageScale && finalMagnifyScale < m_minPageScale) | 889 if (m_minPageScaleFactor && finalMagnifyScale < m_minPageScaleFactor) |
833 delta = m_minPageScale / m_pageScale; | 890 delta = m_minPageScaleFactor / m_pageScaleFactor; |
834 else if (m_maxPageScale && finalMagnifyScale > m_maxPageScale) | 891 else if (m_maxPageScaleFactor && finalMagnifyScale > m_maxPageScaleFactor) |
835 delta = m_maxPageScale / m_pageScale; | 892 delta = m_maxPageScaleFactor / m_pageScaleFactor; |
836 | 893 |
837 if (delta == m_pageScaleDelta) | 894 if (delta == m_pageScaleDelta) |
838 return; | 895 return; |
839 | 896 |
840 m_pageScaleDelta = delta; | 897 m_pageScaleDelta = delta; |
841 | 898 |
842 updateMaxScrollPosition(); | 899 updateMaxScrollPosition(); |
843 if (m_rootScrollLayerImpl) | |
844 m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta); | |
845 } | 900 } |
846 | 901 |
847 void CCLayerTreeHostImpl::updateMaxScrollPosition() | 902 void CCLayerTreeHostImpl::updateMaxScrollPosition() |
848 { | 903 { |
849 if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size()) | 904 if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size()) |
850 return; | 905 return; |
851 | 906 |
852 FloatSize viewBounds = m_deviceViewportSize; | 907 FloatSize viewBounds = m_deviceViewportSize; |
853 if (CCLayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) { | 908 if (CCLayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) { |
854 // Compensate for non-overlay scrollbars. | 909 // Compensate for non-overlay scrollbars. |
855 if (clipLayer->masksToBounds()) { | 910 if (clipLayer->masksToBounds()) { |
856 viewBounds = clipLayer->bounds(); | 911 viewBounds = clipLayer->bounds(); |
857 viewBounds.scale(m_deviceScaleFactor); | 912 viewBounds.scale(m_deviceScaleFactor); |
858 } | 913 } |
859 } | 914 } |
860 viewBounds.scale(1 / m_pageScaleDelta); | 915 viewBounds.scale(1 / m_pageScaleDelta); |
861 | 916 |
862 // maxScroll is computed in physical pixels, but scroll positions are in lay
out pixels. | 917 IntSize contentBounds = contentSize(); |
863 IntSize maxScroll = contentSize() - expandedIntSize(viewBounds); | 918 if (m_applyPinchZoomInImpl) { |
| 919 // Pinch with pageScale scrolls entirely in layout space. contentSize |
| 920 // returns the bounds including the page scale factor, so calculate the |
| 921 // pre page-scale layout size here. |
| 922 contentBounds.setWidth(contentBounds.width() / m_pageScaleFactor); |
| 923 contentBounds.setHeight(contentBounds.height() / m_pageScaleFactor); |
| 924 } |
| 925 |
| 926 IntSize maxScroll = contentBounds - expandedIntSize(viewBounds); |
864 maxScroll.scale(1 / m_deviceScaleFactor); | 927 maxScroll.scale(1 / m_deviceScaleFactor); |
| 928 |
865 // The viewport may be larger than the contents in some cases, such as | 929 // The viewport may be larger than the contents in some cases, such as |
866 // having a vertical scrollbar but no horizontal overflow. | 930 // having a vertical scrollbar but no horizontal overflow. |
867 maxScroll.clampNegativeToZero(); | 931 maxScroll.clampNegativeToZero(); |
868 | 932 |
869 m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll); | 933 m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll); |
870 } | 934 } |
871 | 935 |
872 void CCLayerTreeHostImpl::setNeedsRedraw() | 936 void CCLayerTreeHostImpl::setNeedsRedraw() |
873 { | 937 { |
874 m_client->setNeedsRedrawOnImplThread(); | 938 m_client->setNeedsRedrawOnImplThread(); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
937 m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl; | 1001 m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl; |
938 // Gesture events need to be transformed from screen coordinates to loca
l layer coordinates | 1002 // Gesture events need to be transformed from screen coordinates to loca
l layer coordinates |
939 // so that the scrolling contents exactly follow the user's finger. In c
ontrast, wheel | 1003 // so that the scrolling contents exactly follow the user's finger. In c
ontrast, wheel |
940 // events are already in local layer coordinates so we can just apply th
em directly. | 1004 // events are already in local layer coordinates so we can just apply th
em directly. |
941 m_scrollDeltaIsInScreenSpace = (type == Gesture); | 1005 m_scrollDeltaIsInScreenSpace = (type == Gesture); |
942 return ScrollStarted; | 1006 return ScrollStarted; |
943 } | 1007 } |
944 return ScrollIgnored; | 1008 return ScrollIgnored; |
945 } | 1009 } |
946 | 1010 |
947 static FloatSize scrollLayerWithScreenSpaceDelta(CCLayerImpl& layerImpl, const F
loatPoint& screenSpacePoint, const FloatSize& screenSpaceDelta) | 1011 static FloatSize scrollLayerWithScreenSpaceDelta(CCPinchZoomViewport* viewport,
CCLayerImpl& layerImpl, const FloatPoint& screenSpacePoint, const FloatSize& scr
eenSpaceDelta) |
948 { | 1012 { |
949 // Layers with non-invertible screen space transforms should not have passed
the scroll hit | 1013 // Layers with non-invertible screen space transforms should not have passed
the scroll hit |
950 // test in the first place. | 1014 // test in the first place. |
951 ASSERT(layerImpl.screenSpaceTransform().isInvertible()); | 1015 ASSERT(layerImpl.screenSpaceTransform().isInvertible()); |
952 WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceT
ransform().inverse(); | 1016 WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceT
ransform().inverse(); |
953 | 1017 |
954 // First project the scroll start and end points to local layer space to fin
d the scroll delta | 1018 // First project the scroll start and end points to local layer space to fin
d the scroll delta |
955 // in layer coordinates. | 1019 // in layer coordinates. |
956 bool startClipped, endClipped; | 1020 bool startClipped, endClipped; |
957 FloatPoint screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta; | 1021 FloatPoint screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta; |
958 FloatPoint localStartPoint = CCMathUtil::projectPoint(inverseScreenSpaceTran
sform, screenSpacePoint, startClipped); | 1022 FloatPoint localStartPoint = CCMathUtil::projectPoint(inverseScreenSpaceTran
sform, screenSpacePoint, startClipped); |
959 FloatPoint localEndPoint = CCMathUtil::projectPoint(inverseScreenSpaceTransf
orm, screenSpaceEndPoint, endClipped); | 1023 FloatPoint localEndPoint = CCMathUtil::projectPoint(inverseScreenSpaceTransf
orm, screenSpaceEndPoint, endClipped); |
960 | 1024 |
961 // In general scroll point coordinates should not get clipped. | 1025 // In general scroll point coordinates should not get clipped. |
962 ASSERT(!startClipped); | 1026 ASSERT(!startClipped); |
963 ASSERT(!endClipped); | 1027 ASSERT(!endClipped); |
964 if (startClipped || endClipped) | 1028 if (startClipped || endClipped) |
965 return FloatSize(); | 1029 return FloatSize(); |
966 | 1030 |
967 // Apply the scroll delta. | 1031 // Apply the scroll delta. |
968 FloatSize previousDelta(layerImpl.scrollDelta()); | 1032 FloatSize previousDelta(layerImpl.scrollDelta()); |
969 layerImpl.scrollBy(localEndPoint - localStartPoint); | 1033 FloatSize unscrolled = layerImpl.scrollBy(localEndPoint - localStartPoint); |
| 1034 |
| 1035 if (viewport) |
| 1036 viewport->applyScroll(unscrolled); |
970 | 1037 |
971 // Calculate the applied scroll delta in screen space coordinates. | 1038 // Calculate the applied scroll delta in screen space coordinates. |
972 FloatPoint actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() -
previousDelta; | 1039 FloatPoint actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() -
previousDelta; |
973 FloatPoint actualScreenSpaceEndPoint = CCMathUtil::mapPoint(layerImpl.screen
SpaceTransform(), actualLocalEndPoint, endClipped); | 1040 FloatPoint actualScreenSpaceEndPoint = CCMathUtil::mapPoint(layerImpl.screen
SpaceTransform(), actualLocalEndPoint, endClipped); |
974 ASSERT(!endClipped); | 1041 ASSERT(!endClipped); |
975 if (endClipped) | 1042 if (endClipped) |
976 return FloatSize(); | 1043 return FloatSize(); |
977 return actualScreenSpaceEndPoint - screenSpacePoint; | 1044 return actualScreenSpaceEndPoint - screenSpacePoint; |
978 } | 1045 } |
979 | 1046 |
(...skipping 11 matching lines...) Expand all Loading... |
991 return; | 1058 return; |
992 | 1059 |
993 FloatSize pendingDelta(scrollDelta); | 1060 FloatSize pendingDelta(scrollDelta); |
994 | 1061 |
995 pendingDelta.scale(m_deviceScaleFactor); | 1062 pendingDelta.scale(m_deviceScaleFactor); |
996 | 1063 |
997 for (CCLayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl; laye
rImpl = layerImpl->parent()) { | 1064 for (CCLayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl; laye
rImpl = layerImpl->parent()) { |
998 if (!layerImpl->scrollable()) | 1065 if (!layerImpl->scrollable()) |
999 continue; | 1066 continue; |
1000 | 1067 |
| 1068 CCPinchZoomViewport* viewport = layerImpl == m_rootScrollLayerImpl ? &m_
pinchZoomViewport : 0; |
1001 FloatSize appliedDelta; | 1069 FloatSize appliedDelta; |
1002 if (m_scrollDeltaIsInScreenSpace) | 1070 if (m_scrollDeltaIsInScreenSpace) |
1003 appliedDelta = scrollLayerWithScreenSpaceDelta(*layerImpl, viewportP
oint, pendingDelta); | 1071 appliedDelta = scrollLayerWithScreenSpaceDelta(viewport, *layerImpl,
viewportPoint, pendingDelta); |
1004 else | 1072 else |
1005 appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta); | 1073 appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta); |
1006 | 1074 |
1007 // If the layer wasn't able to move, try the next one in the hierarchy. | 1075 // If the layer wasn't able to move, try the next one in the hierarchy. |
1008 float moveThresholdSquared = 0.1f * 0.1f; | 1076 float moveThresholdSquared = 0.1f * 0.1f; |
1009 if (appliedDelta.diagonalLengthSquared() < moveThresholdSquared) | 1077 if (appliedDelta.diagonalLengthSquared() < moveThresholdSquared) |
1010 continue; | 1078 continue; |
1011 | 1079 |
1012 // If the applied delta is within 45 degrees of the input delta, bail ou
t to make it easier | 1080 // If the applied delta is within 45 degrees of the input delta, bail ou
t to make it easier |
1013 // to scroll just one layer in one direction without affecting any of it
s parents. | 1081 // to scroll just one layer in one direction without affecting any of it
s parents. |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1064 m_previousPinchAnchor = anchor; | 1132 m_previousPinchAnchor = anchor; |
1065 | 1133 |
1066 // Keep the center-of-pinch anchor specified by (x, y) in a stable | 1134 // Keep the center-of-pinch anchor specified by (x, y) in a stable |
1067 // position over the course of the magnify. | 1135 // position over the course of the magnify. |
1068 FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / m_pageScaleDelta,
m_previousPinchAnchor.y() / m_pageScaleDelta); | 1136 FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / m_pageScaleDelta,
m_previousPinchAnchor.y() / m_pageScaleDelta); |
1069 setPageScaleDelta(m_pageScaleDelta * magnifyDelta); | 1137 setPageScaleDelta(m_pageScaleDelta * magnifyDelta); |
1070 FloatPoint newScaleAnchor(anchor.x() / m_pageScaleDelta, anchor.y() / m_page
ScaleDelta); | 1138 FloatPoint newScaleAnchor(anchor.x() / m_pageScaleDelta, anchor.y() / m_page
ScaleDelta); |
1071 FloatSize move = previousScaleAnchor - newScaleAnchor; | 1139 FloatSize move = previousScaleAnchor - newScaleAnchor; |
1072 | 1140 |
1073 m_previousPinchAnchor = anchor; | 1141 m_previousPinchAnchor = anchor; |
| 1142 m_pinchZoomViewport.setTotalPageScaleFactor(m_pageScaleFactor * m_pageScaleD
elta); |
1074 | 1143 |
1075 m_rootScrollLayerImpl->scrollBy(roundedIntSize(move)); | 1144 if (m_applyPinchZoomInImpl) { |
| 1145 // Compute the application of the delta with respect to the current page
zoom of the page. |
| 1146 move.scale(1 / (m_pageScaleFactor * m_deviceScaleFactor)); |
| 1147 } |
| 1148 |
| 1149 FloatSize scrollOverflow = m_applyPinchZoomInImpl? m_pinchZoomViewport.apply
Scroll(move) : move; |
| 1150 m_rootScrollLayerImpl->scrollBy(roundedIntSize(scrollOverflow)); |
1076 | 1151 |
1077 if (m_rootScrollLayerImpl->scrollbarAnimationController()) | 1152 if (m_rootScrollLayerImpl->scrollbarAnimationController()) |
1078 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUp
date(); | 1153 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUp
date(); |
1079 | 1154 |
1080 m_client->setNeedsCommitOnImplThread(); | 1155 m_client->setNeedsCommitOnImplThread(); |
1081 m_client->setNeedsRedrawOnImplThread(); | 1156 m_client->setNeedsRedrawOnImplThread(); |
1082 } | 1157 } |
1083 | 1158 |
1084 void CCLayerTreeHostImpl::pinchGestureEnd() | 1159 void CCLayerTreeHostImpl::pinchGestureEnd() |
1085 { | 1160 { |
1086 m_pinchGestureActive = false; | 1161 m_pinchGestureActive = false; |
1087 | 1162 |
1088 if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationContro
ller()) | 1163 if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationContro
ller()) |
1089 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEn
d(); | 1164 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEn
d(); |
1090 | 1165 |
1091 m_client->setNeedsCommitOnImplThread(); | 1166 m_client->setNeedsCommitOnImplThread(); |
1092 } | 1167 } |
1093 | 1168 |
1094 void CCLayerTreeHostImpl::computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scroll
Info) | 1169 void CCLayerTreeHostImpl::computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scroll
Info) |
1095 { | 1170 { |
1096 float pageScale = m_pageScaleAnimation->finalPageScale(); | 1171 float pageScale = m_pageScaleAnimation->finalPageScale(); |
1097 IntSize scrollOffset = m_pageScaleAnimation->finalScrollOffset(); | 1172 IntSize scrollOffset = m_pageScaleAnimation->finalScrollOffset(); |
1098 scrollOffset.scale(m_pageScale / pageScale); | 1173 scrollOffset.scale(m_pageScaleFactor / pageScale); |
1099 makeScrollAndScaleSet(scrollInfo, scrollOffset, pageScale); | 1174 makeScrollAndScaleSet(scrollInfo, scrollOffset, pageScale); |
1100 } | 1175 } |
1101 | 1176 |
1102 void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo
) | 1177 void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo
) |
1103 { | 1178 { |
1104 if (!m_rootScrollLayerImpl) | 1179 if (!m_rootScrollLayerImpl) |
1105 return; | 1180 return; |
1106 | 1181 |
1107 // Only send fake scroll/zoom deltas if we're pinch zooming out by a | 1182 // Only send fake scroll/zoom deltas if we're pinch zooming out by a |
1108 // significant amount. This also ensures only one fake delta set will be | 1183 // significant amount. This also ensures only one fake delta set will be |
1109 // sent. | 1184 // sent. |
1110 const float pinchZoomOutSensitivity = 0.95f; | 1185 const float pinchZoomOutSensitivity = 0.95f; |
1111 if (m_pageScaleDelta > pinchZoomOutSensitivity) | 1186 if (m_pageScaleDelta > pinchZoomOutSensitivity) |
1112 return; | 1187 return; |
1113 | 1188 |
1114 // Compute where the scroll offset/page scale would be if fully pinch-zoomed | 1189 // Compute where the scroll offset/page scale would be if fully pinch-zoomed |
1115 // out from the anchor point. | 1190 // out from the anchor point. |
1116 IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition()
+ m_rootScrollLayerImpl->scrollDelta()); | 1191 IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition()
+ m_rootScrollLayerImpl->scrollDelta()); |
1117 scrollBegin.scale(m_pageScaleDelta); | 1192 scrollBegin.scale(m_pageScaleDelta); |
1118 float scaleBegin = m_pageScale * m_pageScaleDelta; | 1193 float scaleBegin = m_pageScaleFactor * m_pageScaleDelta; |
1119 float pageScaleDeltaToSend = m_minPageScale / m_pageScale; | 1194 float pageScaleDeltaToSend = m_minPageScaleFactor / m_pageScaleFactor; |
1120 FloatSize scaledContentsSize = contentSize(); | 1195 FloatSize scaledContentsSize = contentSize(); |
1121 scaledContentsSize.scale(pageScaleDeltaToSend); | 1196 scaledContentsSize.scale(pageScaleDeltaToSend); |
1122 | 1197 |
1123 FloatSize anchor = toSize(m_previousPinchAnchor); | 1198 FloatSize anchor = toSize(m_previousPinchAnchor); |
1124 FloatSize scrollEnd = scrollBegin + anchor; | 1199 FloatSize scrollEnd = scrollBegin + anchor; |
1125 scrollEnd.scale(m_minPageScale / scaleBegin); | 1200 scrollEnd.scale(m_minPageScaleFactor / scaleBegin); |
1126 scrollEnd -= anchor; | 1201 scrollEnd -= anchor; |
1127 scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceV
iewportSize)).expandedTo(FloatSize(0, 0)); | 1202 scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceV
iewportSize)).expandedTo(FloatSize(0, 0)); |
1128 scrollEnd.scale(1 / pageScaleDeltaToSend); | 1203 scrollEnd.scale(1 / pageScaleDeltaToSend); |
1129 scrollEnd.scale(m_deviceScaleFactor); | 1204 scrollEnd.scale(m_deviceScaleFactor); |
1130 | 1205 |
1131 makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScale)
; | 1206 makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScaleF
actor); |
1132 } | 1207 } |
1133 | 1208 |
1134 void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo,
const IntSize& scrollOffset, float pageScale) | 1209 void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo,
const IntSize& scrollOffset, float pageScale) |
1135 { | 1210 { |
1136 if (!m_rootScrollLayerImpl) | 1211 if (!m_rootScrollLayerImpl) |
1137 return; | 1212 return; |
1138 | 1213 |
1139 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; | 1214 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; |
1140 scroll.layerId = m_rootScrollLayerImpl->id(); | 1215 scroll.layerId = m_rootScrollLayerImpl->id(); |
1141 scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosi
tion()); | 1216 scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosi
tion()); |
1142 scrollInfo->scrolls.append(scroll); | 1217 scrollInfo->scrolls.append(scroll); |
1143 m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta); | 1218 m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta); |
1144 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScale; | 1219 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScaleF
actor; |
1145 } | 1220 } |
1146 | 1221 |
1147 static void collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* la
yerImpl) | 1222 static void collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* la
yerImpl) |
1148 { | 1223 { |
1149 if (!layerImpl) | 1224 if (!layerImpl) |
1150 return; | 1225 return; |
1151 | 1226 |
1152 if (!layerImpl->scrollDelta().isZero()) { | 1227 if (!layerImpl->scrollDelta().isZero()) { |
1153 IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta()); | 1228 IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta()); |
1154 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; | 1229 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; |
1155 scroll.layerId = layerImpl->id(); | 1230 scroll.layerId = layerImpl->id(); |
1156 scroll.scrollDelta = scrollDelta; | 1231 scroll.scrollDelta = scrollDelta; |
1157 scrollInfo->scrolls.append(scroll); | 1232 scrollInfo->scrolls.append(scroll); |
1158 layerImpl->setSentScrollDelta(scrollDelta); | 1233 layerImpl->setSentScrollDelta(scrollDelta); |
1159 } | 1234 } |
1160 | 1235 |
1161 for (size_t i = 0; i < layerImpl->children().size(); ++i) | 1236 for (size_t i = 0; i < layerImpl->children().size(); ++i) |
1162 collectScrollDeltas(scrollInfo, layerImpl->children()[i]); | 1237 collectScrollDeltas(scrollInfo, layerImpl->children()[i]); |
1163 } | 1238 } |
1164 | 1239 |
1165 PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas() | 1240 PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas() |
1166 { | 1241 { |
1167 OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet())
; | 1242 OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet())
; |
1168 | 1243 |
1169 if (m_pinchGestureActive || m_pageScaleAnimation) { | 1244 if (m_pinchGestureActive || m_pageScaleAnimation) { |
1170 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1; | 1245 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1; |
1171 if (m_pinchGestureActive) | 1246 // If pinch zoom is applied in the impl thread, then there is no need to |
1172 computePinchZoomDeltas(scrollInfo.get()); | 1247 // calculate these intermediate scale deltas. |
1173 else if (m_pageScaleAnimation.get()) | 1248 if (!m_applyPinchZoomInImpl) { |
1174 computeDoubleTapZoomDeltas(scrollInfo.get()); | 1249 if (m_pinchGestureActive) |
| 1250 computePinchZoomDeltas(scrollInfo.get()); |
| 1251 else if (m_pageScaleAnimation.get()) |
| 1252 computeDoubleTapZoomDeltas(scrollInfo.get()); |
| 1253 } |
1175 return scrollInfo.release(); | 1254 return scrollInfo.release(); |
1176 } | 1255 } |
1177 | 1256 |
1178 collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get()); | 1257 collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get()); |
1179 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = m_pageScaleDelta; | 1258 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = m_pageScaleDelta; |
1180 | 1259 |
1181 return scrollInfo.release(); | 1260 return scrollInfo.release(); |
1182 } | 1261 } |
1183 | 1262 |
| 1263 WebTransformationMatrix CCLayerTreeHostImpl::implTransform() const |
| 1264 { |
| 1265 WebTransformationMatrix transform; |
| 1266 transform.scale(m_pageScaleDelta); |
| 1267 |
| 1268 // If the pinch state is applied in the impl, then push it to the |
| 1269 // impl transform, otherwise the scale is handled by WebCore. |
| 1270 if (m_applyPinchZoomInImpl) { |
| 1271 transform.scale(m_pageScaleFactor); |
| 1272 transform.translate(-m_pinchZoomViewport.scrollDelta().x(), |
| 1273 -m_pinchZoomViewport.scrollDelta().y()); |
| 1274 } |
| 1275 |
| 1276 return transform; |
| 1277 } |
| 1278 |
1184 void CCLayerTreeHostImpl::setFullRootLayerDamage() | 1279 void CCLayerTreeHostImpl::setFullRootLayerDamage() |
1185 { | 1280 { |
1186 if (m_rootLayerImpl) { | 1281 if (m_rootLayerImpl) { |
1187 CCRenderSurface* renderSurface = m_rootLayerImpl->renderSurface(); | 1282 CCRenderSurface* renderSurface = m_rootLayerImpl->renderSurface(); |
1188 if (renderSurface) | 1283 if (renderSurface) |
1189 renderSurface->damageTracker()->forceFullDamageNextUpdate(); | 1284 renderSurface->damageTracker()->forceFullDamageNextUpdate(); |
1190 } | 1285 } |
1191 } | 1286 } |
1192 | 1287 |
1193 void CCLayerTreeHostImpl::animatePageScale(double monotonicTime) | 1288 void CCLayerTreeHostImpl::animatePageScale(double monotonicTime) |
1194 { | 1289 { |
1195 if (!m_pageScaleAnimation || !m_rootScrollLayerImpl) | 1290 if (!m_pageScaleAnimation || !m_rootScrollLayerImpl) |
1196 return; | 1291 return; |
1197 | 1292 |
1198 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition()
+ m_rootScrollLayerImpl->scrollDelta()); | 1293 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition()
+ m_rootScrollLayerImpl->scrollDelta()); |
1199 | 1294 |
1200 setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_p
ageScale); | 1295 setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_p
ageScaleFactor); |
1201 IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime)
; | 1296 IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime)
; |
1202 nextScroll.scale(1 / m_pageScaleDelta); | 1297 nextScroll.scale(1 / m_pageScaleDelta); |
1203 m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal); | 1298 m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal); |
1204 m_client->setNeedsRedrawOnImplThread(); | 1299 m_client->setNeedsRedrawOnImplThread(); |
1205 | 1300 |
1206 if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) { | 1301 if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) { |
1207 m_pageScaleAnimation.clear(); | 1302 m_pageScaleAnimation.clear(); |
1208 m_client->setNeedsCommitOnImplThread(); | 1303 m_client->setNeedsCommitOnImplThread(); |
1209 } | 1304 } |
1210 } | 1305 } |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1304 | 1399 |
1305 CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimat
ionController(); | 1400 CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimat
ionController(); |
1306 if (scrollbarController && scrollbarController->animate(monotonicTime)) | 1401 if (scrollbarController && scrollbarController->animate(monotonicTime)) |
1307 m_client->setNeedsRedrawOnImplThread(); | 1402 m_client->setNeedsRedrawOnImplThread(); |
1308 | 1403 |
1309 for (size_t i = 0; i < layer->children().size(); ++i) | 1404 for (size_t i = 0; i < layer->children().size(); ++i) |
1310 animateScrollbarsRecursive(layer->children()[i], monotonicTime); | 1405 animateScrollbarsRecursive(layer->children()[i], monotonicTime); |
1311 } | 1406 } |
1312 | 1407 |
1313 } // namespace cc | 1408 } // namespace cc |
OLD | NEW |