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

Side by Side Diff: cc/CCLayerTreeHostImpl.cpp

Issue 10916279: Chromium compositor change implementing page-scale driven pinch-zoom. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: Reduce number of prepared tiles and correct existing tests. Created 8 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
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
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
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
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
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
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
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
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
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
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
OLDNEW
« no previous file with comments | « cc/CCLayerTreeHostImpl.h ('k') | cc/CCLayerTreeHostImplTest.cpp » ('j') | cc/CCSettings.cpp » ('J')

Powered by Google App Engine
This is Rietveld 408576698