Plumb an overscroll callback form the compositor to the Android UI 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 751 matching lines @@
         metadata.location_bar_offset = gfx::Vector2dF(0.f, m_topControlsManager->controls_top_offset());
         metadata.location_bar_content_translation = gfx::Vector2dF(0.f, m_topControlsManager->content_top_offset());
     }
 
     if (!rootScrollLayer())
       return metadata;
 
     metadata.root_scroll_offset = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
     if (!m_settings.pageScalePinchZoomEnabled)
         metadata.root_scroll_offset.Scale(1 / m_pinchZoomViewport.page_scale_factor());
+    metadata.unused_scroll_delta = m_pendingScrollDelta;
+    m_pendingScrollDelta = gfx::Vector2dF();

[mkosiba (inactive), 2013/01/30 14:46:23]

where would be a good place to reset is variable? I tried doing that in
OnSendFrameToParentCompositorAck, didDrawAllLayers and processScrollDeltas but
all of those seem to happen too early.

[aelias_OOO_until_Jul13, 2013/01/30 18:02:48]

I guess it's okay to do it here.  You can remove the const from the method.

 
     return metadata;
 }
 
 void LayerTreeHostImpl::drawLayers(FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
     DCHECK(canDraw());
     DCHECK(!frame.renderPasses.empty());
 
@@ skipping 19 matching lines @@
     for (unsigned int i = 0; i < frame.renderSurfaceLayerList->size(); i++)
         (*frame.renderSurfaceLayerList)[i]->renderSurface()->damageTracker()->didDrawDamagedArea();
     rootLayer()->resetAllChangeTrackingForSubtree();
 }
 
 void LayerTreeHostImpl::didDrawAllLayers(const FrameData& frame)
 {
     for (size_t i = 0; i < frame.willDrawLayers.size(); ++i)
         frame.willDrawLayers[i]->didDraw(m_resourceProvider.get());
 
+
     // Once all layers have been drawn, pending texture uploads should no
     // longer block future uploads.
     m_resourceProvider->markPendingUploadsAsNonBlocking();
 }
 
 void LayerTreeHostImpl::finishAllRendering()
 {
     if (m_renderer)
         m_renderer->finish();
 }
@@ skipping 495 matching lines @@
 }
 
 bool LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint,
                                  const gfx::Vector2d& scrollDelta)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBy");
     if (!currentlyScrollingLayer())
         return false;
 
     gfx::Vector2dF pendingDelta = scrollDelta;
+    gfx::Vector2dF overScrollDelta = scrollDelta;

[aelias_OOO_until_Jul13, 2013/01/30 18:02:48]

Call this "unused" for consistency.

     bool didScroll = false;
 
     for (LayerImpl* layerImpl = currentlyScrollingLayer(); layerImpl; layerImpl = layerImpl->parent()) {
         if (!layerImpl->scrollable())
             continue;
 
         gfx::Vector2dF appliedDelta;
         if (m_topControlsManager && layerImpl == rootScrollLayer())
             pendingDelta = m_topControlsManager->ScrollBy(pendingDelta);
 
         if (m_scrollDeltaIsInViewportSpace) {
             float scaleFromViewportToScreenSpace = m_deviceScaleFactor;
             appliedDelta = scrollLayerWithViewportSpaceDelta(layerImpl, scaleFromViewportToScreenSpace, viewportPoint, pendingDelta);
         } else
             appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta);
 
         // 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;
+        overScrollDelta.Subtract(appliedDelta);
 
         // 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) {
             pendingDelta = gfx::Vector2d();
             break;
         }
 
         // 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;
     }
 
-    if (didScroll) {
+    m_pendingScrollDelta += overScrollDelta;
+
+    if (didScroll || !gfx::ToFlooredVector2d(overScrollDelta).IsZero()) {

[mkosiba (inactive), 2013/01/30 14:46:23]

this makes us draw frames even though the contents of those frames would not
change. is there a simple change I could do to optimize that away or is it not
worth it?

[aelias_OOO_until_Jul13, 2013/01/30 18:02:48]

I think the redraw itself is okay but let's avoid the commit and tree priority
update, you shouldn't need those.

         m_client->setNeedsCommitOnImplThread();
         m_client->setNeedsRedrawOnImplThread();
         m_client->renewTreePriority();
     }
+
     return didScroll;
 }
 
 void LayerTreeHostImpl::clearCurrentlyScrollingLayer()
 {
     m_activeTree->ClearCurrentlyScrollingLayer();
 }
 
 void LayerTreeHostImpl::scrollEnd()
 {
@@ skipping 362 matching lines @@
     LayerImpl* layer = getNonCompositedContentLayerRecursive(tree->RootLayer());
     return layer ? layer->getPicture() : skia::RefPtr<SkPicture>();
 }
 
 void LayerTreeHostImpl::savePaintTime(const base::TimeDelta& totalPaintTime)
 {
     m_paintTimeCounter->SavePaintTime(totalPaintTime);
 }
 
 }  // namespace cc