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