Make LayerScrollOffsetDelegate updates consistent.

cc/trees/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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 2667 matching lines @@
     top_controls_manager_->PinchBegin();
 }
 
 void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
                                            const gfx::Point& anchor) {
   if (!InnerViewportScrollLayer())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
 
+  // For a moment the scroll offset ends up being outside of the max range. This
+  // confuses the delegate so we switch it off till after we're done processing
+  // the pinch update.
+  active_tree_->SetRootLayerScrollOffsetDelegate(NULL);

[aelias_OOO_until_Jul13, 2014/05/09 01:00:01]

Is there any way to avoid this workaround by changing the order that things
happen in the scrolling guts?  I don't understand quite what the problem is from
code inspection, I guess either a clamp or a max scroll offset update happens
too late?

[mkosiba (inactive), 2014/05/09 17:05:33]

AFAICT the problem is caused by 2 things:
a) the LayerImpl::MaxScrollOffset seems to now depend on pagescale,
b) updating the scroll offset on one of the viewport causes an update on the
delegate.

I think the above makes it quite hard to change the scroll offset in a way that
doesn't result in the delegate seeing an intermediate value (even though it
might be possible to change this in a way that makes the delegate not see a
value that's outside of the max range).

+
   // Keep the center-of-pinch anchor specified by (x, y) in a stable
   // position over the course of the magnify.
   float page_scale_delta = active_tree_->page_scale_delta();
   gfx::PointF previous_scale_anchor =
       gfx::ScalePoint(anchor, 1.f / page_scale_delta);
   active_tree_->SetPageScaleDelta(page_scale_delta * magnify_delta);
   page_scale_delta = active_tree_->page_scale_delta();
   gfx::PointF new_scale_anchor =
       gfx::ScalePoint(anchor, 1.f / page_scale_delta);
   gfx::Vector2dF move = previous_scale_anchor - new_scale_anchor;
@@ skipping 13 matching lines @@
   // 3) pinching should not engage the top controls manager.
   gfx::Vector2dF unused = OuterViewportScrollLayer()
                               ? OuterViewportScrollLayer()->ScrollBy(move)
                               : move;
 
   if (!unused.IsZero()) {
     InnerViewportScrollLayer()->ScrollBy(unused);
     InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
   }
 
+  active_tree_->SetRootLayerScrollOffsetDelegate(
+      root_layer_scroll_offset_delegate_);
+
   client_->SetNeedsCommitOnImplThread();
   SetNeedsRedraw();
   client_->RenewTreePriority();
 }
 
 void LayerTreeHostImpl::PinchGestureEnd() {
   pinch_gesture_active_ = false;
   if (pinch_gesture_end_should_clear_scrolling_layer_) {
     pinch_gesture_end_should_clear_scrolling_layer_ = false;
     ClearCurrentlyScrollingLayer();
@@ skipping 420 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc