Implement pinch-zoom scaling for main-frame scrollbars and pinch-zoom overlay scrollbars.

cc/layer_tree_host_impl.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 1178 matching lines @@
     // in the most recent frame.
     LayerImpl* layerImpl = LayerTreeHostCommon::findLayerThatIsHitByPoint(deviceViewportPoint, activeTree()->RenderSurfaceLayerList());
 
     // Walk up the hierarchy and look for a scrollable layer.
     LayerImpl* potentiallyScrollingLayerImpl = 0;
     for (; layerImpl; layerImpl = layerImpl->parent()) {
         // The content layer can also block attempts to scroll outside the main thread.
         if (layerImpl->tryScroll(deviceViewportPoint, type) == ScrollOnMainThread) {
             m_numMainThreadScrolls++;
             UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
+            if (activeTree()->HasPinchZoomScrollbars())

[enne (OOO), 2013/03/06 19:32:58]

Can LayerTreeHostImpl be less aware of pinch zoom scrollbars and instead just
have an API on LayerTreeImpl like DidBeginScroll(), DidUpdateScroll(),
DidEndScroll()? This would encapsulate the pinch zoom scrollbar updates and
animations inside of LayerTreeImpl and LayerTreeImpl would no longer need to
expose so many accessors and updaters.

[wjmaclean, 2013/03/06 22:36:53]

Sounds like a good idea! Done.

+                activeTree()->FadeInPinchZoomScrollbars();
             return ScrollOnMainThread;
         }
 
         LayerImpl* scrollLayerImpl = findScrollLayerForContentLayer(layerImpl);
         if (!scrollLayerImpl)
             continue;
 
         ScrollStatus status = scrollLayerImpl->tryScroll(deviceViewportPoint, type);
 
         // If any layer wants to divert the scroll event to the main thread, abort.
         if (status == ScrollOnMainThread) {
             m_numMainThreadScrolls++;
             UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
+            if (activeTree()->HasPinchZoomScrollbars())
+                activeTree()->FadeInPinchZoomScrollbars();
             return ScrollOnMainThread;
         }
 
         if (status == ScrollStarted && !potentiallyScrollingLayerImpl)
             potentiallyScrollingLayerImpl = scrollLayerImpl;
     }
 
     // When hiding top controls is enabled and the controls are hidden or
     // overlaying the content, force scrolls to be enabled on the root layer to
     // allow bringing the top controls back into view.
     if (!potentiallyScrollingLayerImpl && m_topControlsManager &&
             m_topControlsManager->content_top_offset() != m_settings.topControlsHeight) {
         potentiallyScrollingLayerImpl = rootScrollLayer();
     }
 
     if (potentiallyScrollingLayerImpl) {
         m_activeTree->set_currently_scrolling_layer(potentiallyScrollingLayerImpl);
         m_shouldBubbleScrolls = (type != NonBubblingGesture);
         m_wheelScrolling = (type == Wheel);
         m_numImplThreadScrolls++;
         m_client->renewTreePriority();
         UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
+        if (activeTree()->HasPinchZoomScrollbars())
+            activeTree()->FadeInPinchZoomScrollbars();
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::scrollLayerWithViewportSpaceDelta(LayerImpl* layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
     DCHECK(layerImpl->screenSpaceTransform().IsInvertible());
@@ skipping 103 matching lines @@
 
         // Allow further movement only on an axis perpendicular to the direction in which the layer
         // moved.
         gfx::Vector2dF perpendicularAxis(-appliedDelta.y(), appliedDelta.x());
         pendingDelta = MathUtil::projectVector(pendingDelta, perpendicularAxis);
 
         if (gfx::ToFlooredVector2d(pendingDelta).IsZero())
             break;
     }
 
+    activeTree()->UpdatePinchZoomScrollbarsIfNeeded(
+      LayerTreeImpl::UPDATE_IMPL_THREAD_SCROLL);
     if (didScroll) {
         m_client->setNeedsCommitOnImplThread();
         m_client->setNeedsRedrawOnImplThread();
         m_client->renewTreePriority();
     }
     return didScroll;
 }
 
 void LayerTreeHostImpl::clearCurrentlyScrollingLayer()
 {
     m_activeTree->ClearCurrentlyScrollingLayer();
     m_didLockScrollingLayer = false;
 }
 
 void LayerTreeHostImpl::scrollEnd()
 {
     if (m_topControlsManager)
         m_topControlsManager->ScrollEnd();
     clearCurrentlyScrollingLayer();
+    if (activeTree()->HasPinchZoomScrollbars())
+        activeTree()->FadeOutPinchZoomScrollbars();
 }
 
 void LayerTreeHostImpl::pinchGestureBegin()
 {
     m_pinchGestureActive = true;
     m_previousPinchAnchor = gfx::Point();
     m_client->renewTreePriority();
 }
 
 void LayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta, gfx::Point anchor)
@@ skipping 337 matching lines @@
         m_tileManager->SetRecordRenderingStats(m_debugState.recordRenderingStats());
 }
 
 void LayerTreeHostImpl::savePaintTime(const base::TimeDelta& totalPaintTime, int commitNumber)
 {
     DCHECK(m_debugState.continuousPainting);
     m_paintTimeCounter->SavePaintTime(totalPaintTime, commitNumber);
 }
 
 }  // namespace cc