Implement one-page-at-a-time mousewheel scrolling in the impl thread.

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 1237 matching lines @@
 }
 
 static gfx::Vector2dF scrollLayerWithLocalDelta(LayerImpl& layerImpl, gfx::Vector2dF localDelta)
 {
     gfx::Vector2dF previousDelta(layerImpl.scrollDelta());
     layerImpl.scrollBy(localDelta);
     return layerImpl.scrollDelta() - previousDelta;
 }
 
 bool LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint,
-                                 const gfx::Vector2d& scrollDelta)
+                                 const gfx::Vector2d& scrollDelta,
+                                 bool scrollByPage)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBy");
     if (!currentlyScrollingLayer())
         return false;
 
     gfx::Vector2dF pendingDelta = scrollDelta;
     bool didScroll = false;
 
     for (LayerImpl* layerImpl = currentlyScrollingLayer(); layerImpl; layerImpl = layerImpl->parent()) {
         if (!layerImpl->scrollable())
             continue;
 
         PinchZoomViewport* viewport = NULL;
         if (m_settings.pageScalePinchZoomEnabled && layerImpl == rootScrollLayer())
             viewport = &m_pinchZoomViewport;
         gfx::Vector2dF appliedDelta;
+        gfx::Size visibleScrollArea = layerImpl->visibleScrollArea();
+        if (scrollByPage)
+            pendingDelta = gfx::ScaleVector2d(pendingDelta, visibleScrollArea.width(), visibleScrollArea.height());

[jamesr, 2013/03/06 23:50:37]

This seems a bit strange.  scrollByPage is only valid for mousewheels and wheels
can't be diagonal.

+
         if (m_topControlsManager && layerImpl == rootScrollLayer())
             pendingDelta = m_topControlsManager->ScrollBy(pendingDelta);
 
         if (m_scrollDeltaIsInViewportSpace) {
             float scaleFromViewportToScreenSpace = m_deviceScaleFactor;
             appliedDelta = scrollLayerWithViewportSpaceDelta(viewport, *layerImpl, scaleFromViewportToScreenSpace, viewportPoint, pendingDelta);
         } else
             appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta);
 
+        if (scrollByPage) {
+            if (visibleScrollArea.width() != 0.0)
+                appliedDelta.set_x(appliedDelta.x() / visibleScrollArea.width());
+            if (visibleScrollArea.height() != 0.0)
+                appliedDelta.set_y(appliedDelta.y() / visibleScrollArea.height());
+        }
+
         // If the layer wasn't able to move, try the next one in the hierarchy.
         float moveThresholdSquared = 0.1f * 0.1f;
         if (appliedDelta.LengthSquared() < moveThresholdSquared)
             continue;
         didScroll = true;
 
         // If the applied delta is within 45 degrees of the input delta, bail out to make it easier
         // to scroll just one layer in one direction without affecting any of its parents.
         float angleThreshold = 45;
         if (MathUtil::smallestAngleBetweenVectors(appliedDelta, pendingDelta) < angleThreshold) {
@@ skipping 377 matching lines @@
 }
 
 skia::RefPtr<SkPicture> LayerTreeHostImpl::capturePicture()
 {
     LayerTreeImpl* tree = pendingTree() ? pendingTree() : activeTree();
     LayerImpl* layer = getNonCompositedContentLayerRecursive(tree->RootLayer());
     return layer ? layer->getPicture() : skia::RefPtr<SkPicture>();
 }
 
 }  // namespace cc