Refactor delegated scrolling in LayerImpl

cc/trees/layer_tree_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_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/animation/scrollbar_animation_controller_linear_fade.h"
 #include "cc/animation/scrollbar_animation_controller_thinning.h"
 #include "cc/base/math_util.h"
 #include "cc/base/synced_property.h"
 #include "cc/base/util.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
+#include "cc/input/layer_scroll_offset_delegate.h"
 #include "cc/input/page_scale_animation.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/layers/scrollbar_layer_impl_base.h"
 #include "cc/resources/ui_resource_request.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
-// This class exists to split the LayerScrollOffsetDelegate between the
-// InnerViewportScrollLayer and the OuterViewportScrollLayer in a manner
-// that never requires the embedder or LayerImpl to know about.
-class LayerScrollOffsetDelegateProxy : public LayerImpl::ScrollOffsetDelegate {
+
+// This class listens to the scroll offset changes of inner and outer viewport
+// scroll layer.  When they change, the root layer scroll offset delegate needs
+// to be updated accordingly.
+class LayerExternalScrollOffsetListener
+    : public LayerImpl::ExternalScrollOffsetListener {
  public:
-  LayerScrollOffsetDelegateProxy(LayerImpl* layer,
-                                 LayerScrollOffsetDelegate* delegate,
-                                 LayerTreeImpl* layer_tree)
-      : layer_(layer), delegate_(delegate), layer_tree_impl_(layer_tree) {}
-  virtual ~LayerScrollOffsetDelegateProxy() {}
+  LayerExternalScrollOffsetListener(LayerScrollOffsetDelegate* delegate,
+                                    LayerTreeImpl* layer_tree)
+      : root_delegate_(delegate), layer_tree_impl_(layer_tree) {}
+  virtual ~LayerExternalScrollOffsetListener() {}
 
-  gfx::ScrollOffset last_set_scroll_offset() const {
-    return last_set_scroll_offset_;
+  bool IsExternalFlingActive() const override {
+    return root_delegate_->IsExternalFlingActive();
   }
 
-  // LayerScrollOffsetDelegate implementation.
-  void SetCurrentScrollOffset(const gfx::ScrollOffset& new_offset) override {
-    last_set_scroll_offset_ = new_offset;
-  }
-
-  gfx::ScrollOffset GetCurrentScrollOffset() override {
-    return layer_tree_impl_->GetDelegatedScrollOffset(layer_);
-  }
-
-  bool IsExternalFlingActive() const override {
-    return delegate_->IsExternalFlingActive();
-  }
-
-  void Update() const override {
-    layer_tree_impl_->UpdateScrollOffsetDelegate();
+  void DidUpdateScrollOffset() const override {
+    layer_tree_impl_->UpdateRootScrollOffsetDelegate();
   }
 
  private:
-  LayerImpl* layer_;
-  LayerScrollOffsetDelegate* delegate_;
+  LayerScrollOffsetDelegate* root_delegate_;
   LayerTreeImpl* layer_tree_impl_;
-  gfx::ScrollOffset last_set_scroll_offset_;
 };
 
 LayerTreeImpl::LayerTreeImpl(
     LayerTreeHostImpl* layer_tree_host_impl,
     scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor,
     scoped_refptr<SyncedTopControls> top_controls_shown_ratio,
     scoped_refptr<SyncedElasticOverscroll> elastic_overscroll)
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
       hud_layer_(0),
@@ skipping 59 matching lines @@
   // that, we need to inform LayerTreeImpl whenever there are requests when we
   // get them.
   LayerTreeHostCommon::CallFunctionForSubtree(
       root_layer_.get(), [request_ids](LayerImpl* layer) {
         layer->GatherFrameTimingRequestIds(request_ids);
       });
 }
 
 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
   if (inner_viewport_scroll_layer_)
-    inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
+    inner_viewport_scroll_layer_->SetExternalScrollOffsetListener(NULL);
   if (outer_viewport_scroll_layer_)
-    outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
-  inner_viewport_scroll_delegate_proxy_ = nullptr;
-  outer_viewport_scroll_delegate_proxy_ = nullptr;
+    outer_viewport_scroll_layer_->SetExternalScrollOffsetListener(NULL);
+  layer_scroll_offset_listener_ = nullptr;
 
   root_layer_ = layer.Pass();
   currently_scrolling_layer_ = NULL;
   inner_viewport_scroll_layer_ = NULL;
   outer_viewport_scroll_layer_ = NULL;
   page_scale_layer_ = NULL;
 
   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
@@ skipping 27 matching lines @@
     offset += outer_viewport_scroll_layer_->MaxScrollOffset();
 
   return offset;
 }
 
 scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() {
   // Clear all data structures that have direct references to the layer tree.
   scrolling_layer_id_from_previous_tree_ =
     currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
   if (inner_viewport_scroll_layer_)
-    inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
+    inner_viewport_scroll_layer_->SetExternalScrollOffsetListener(NULL);
   if (outer_viewport_scroll_layer_)
-    outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
-  inner_viewport_scroll_delegate_proxy_ = nullptr;
-  outer_viewport_scroll_delegate_proxy_ = nullptr;
+    outer_viewport_scroll_layer_->SetExternalScrollOffsetListener(NULL);
+  layer_scroll_offset_listener_ = nullptr;
   inner_viewport_scroll_layer_ = NULL;
   outer_viewport_scroll_layer_ = NULL;
   page_scale_layer_ = NULL;
   currently_scrolling_layer_ = NULL;
 
   render_surface_layer_list_.clear();
   set_needs_update_draw_properties();
   return root_layer_.Pass();
 }
 
@@ skipping 305 matching lines @@
   outer_viewport_scroll_layer_ =
       LayerById(outer_viewport_scroll_layer_id);
   DCHECK(outer_viewport_scroll_layer_ ||
          outer_viewport_scroll_layer_id == Layer::INVALID_ID);
 
   HideInnerViewportScrollbarsIfNearMinimumScale();
 
   if (!root_layer_scroll_offset_delegate_)
     return;
 
-  inner_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
-      new LayerScrollOffsetDelegateProxy(inner_viewport_scroll_layer_,
-                                         root_layer_scroll_offset_delegate_,
-                                         this));
-
-  if (outer_viewport_scroll_layer_)
-    outer_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
-        new LayerScrollOffsetDelegateProxy(outer_viewport_scroll_layer_,
-                                           root_layer_scroll_offset_delegate_,
-                                           this));
+  layer_scroll_offset_listener_ =
+      make_scoped_ptr(new LayerExternalScrollOffsetListener(
+          root_layer_scroll_offset_delegate_, this));
 }
 
 void LayerTreeImpl::ClearViewportLayers() {
   page_scale_layer_ = NULL;
   inner_viewport_scroll_layer_ = NULL;
   outer_viewport_scroll_layer_ = NULL;
 }
 
 bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text) {
   if (!needs_update_draw_properties_)
@@ skipping 482 matching lines @@
 
 void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
     LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
   if (root_layer_scroll_offset_delegate_ == root_layer_scroll_offset_delegate)
     return;
 
   if (!root_layer_scroll_offset_delegate) {
     // Make sure we remove the proxies from their layers before
     // releasing them.
     if (InnerViewportScrollLayer())
-      InnerViewportScrollLayer()->SetScrollOffsetDelegate(NULL);
+      InnerViewportScrollLayer()->SetExternalScrollOffsetListener(NULL);
     if (OuterViewportScrollLayer())
-      OuterViewportScrollLayer()->SetScrollOffsetDelegate(NULL);
-    inner_viewport_scroll_delegate_proxy_ = nullptr;
-    outer_viewport_scroll_delegate_proxy_ = nullptr;
+      OuterViewportScrollLayer()->SetExternalScrollOffsetListener(NULL);
+    layer_scroll_offset_listener_ = nullptr;
   }
 
   root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
 
   if (root_layer_scroll_offset_delegate_) {
     root_layer_scroll_offset_delegate_->UpdateRootLayerState(
         TotalScrollOffset(), TotalMaxScrollOffset(), ScrollableSize(),
         current_page_scale_factor(), min_page_scale_factor(),
         max_page_scale_factor());
 
+    layer_scroll_offset_listener_ =
+        make_scoped_ptr(new LayerExternalScrollOffsetListener(
+            root_layer_scroll_offset_delegate_, this));
+
     if (inner_viewport_scroll_layer_) {
-      inner_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
-          new LayerScrollOffsetDelegateProxy(InnerViewportScrollLayer(),
-                                             root_layer_scroll_offset_delegate_,
-                                             this));
-      inner_viewport_scroll_layer_->SetScrollOffsetDelegate(
-          inner_viewport_scroll_delegate_proxy_.get());
+      inner_viewport_scroll_layer_->SetExternalScrollOffsetListener(
+          layer_scroll_offset_listener_.get());
     }
 
     if (outer_viewport_scroll_layer_) {
-      outer_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
-          new LayerScrollOffsetDelegateProxy(OuterViewportScrollLayer(),
-                                             root_layer_scroll_offset_delegate_,
-                                             this));
-      outer_viewport_scroll_layer_->SetScrollOffsetDelegate(
-          outer_viewport_scroll_delegate_proxy_.get());
+      outer_viewport_scroll_layer_->SetExternalScrollOffsetListener(
+          layer_scroll_offset_listener_.get());
     }
 
-    if (inner_viewport_scroll_layer_)
-      inner_viewport_scroll_layer_->RefreshFromScrollDelegate();
-    if (outer_viewport_scroll_layer_)
-      outer_viewport_scroll_layer_->RefreshFromScrollDelegate();
-
-    if (inner_viewport_scroll_layer_)
-      UpdateScrollOffsetDelegate();
+    DistributeRootScrollOffset();
   }
 }
 
-void LayerTreeImpl::OnRootLayerDelegatedScrollOffsetChanged() {
-  DCHECK(root_layer_scroll_offset_delegate_);
-  if (inner_viewport_scroll_layer_) {
-    inner_viewport_scroll_layer_->RefreshFromScrollDelegate();
-  }
-  if (outer_viewport_scroll_layer_) {
-    outer_viewport_scroll_layer_->RefreshFromScrollDelegate();
-  }
-}
-
-void LayerTreeImpl::UpdateScrollOffsetDelegate() {
-  DCHECK(InnerViewportScrollLayer());
-  DCHECK(!OuterViewportScrollLayer() || outer_viewport_scroll_delegate_proxy_);
+void LayerTreeImpl::UpdateRootScrollOffsetDelegate() {
   DCHECK(root_layer_scroll_offset_delegate_);
 
-  gfx::ScrollOffset offset =
-      inner_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
+  gfx::ScrollOffset offset = InnerViewportScrollLayer()->CurrentScrollOffset();
 
   if (OuterViewportScrollLayer())
-    offset += outer_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
+    offset += OuterViewportScrollLayer()->CurrentScrollOffset();
 
   root_layer_scroll_offset_delegate_->UpdateRootLayerState(
       offset, TotalMaxScrollOffset(), ScrollableSize(),
       current_page_scale_factor(), min_page_scale_factor(),
       max_page_scale_factor());
 }
 
-gfx::ScrollOffset LayerTreeImpl::GetDelegatedScrollOffset(LayerImpl* layer) {
-  DCHECK(root_layer_scroll_offset_delegate_);
-  DCHECK(InnerViewportScrollLayer());
-  if (layer == InnerViewportScrollLayer() && !OuterViewportScrollLayer())
-    return root_layer_scroll_offset_delegate_->GetTotalScrollOffset();
+void LayerTreeImpl::DistributeRootScrollOffset() {
+  if (!root_layer_scroll_offset_delegate_)
+    return;
+
+  gfx::ScrollOffset root_offset =
+      root_layer_scroll_offset_delegate_->GetTotalScrollOffset();
+
+  if (!InnerViewportScrollLayer())
+    return;
+
+  if (!OuterViewportScrollLayer()) {

[aelias_OOO_until_Jul13, 2015/04/06 19:57:32]

You can delete this block and DCHECK that an OuterViewportScrollLayer exists
instead.  The old path of InnerViewportScrollLayer-only is no longer shipping.

[hush (inactive), 2015/04/06 23:08:03]

The tests are exercising the InnerViewportScrollLayer-only logic a lot.
LayerTreeHostImplTests that invoke CreateScrollAndContentsLayers() will only
create the inner scroll layer.
There are a large number of such tests.. I will just put a TODO here while I am
rewriting these tests.

+    InnerViewportScrollLayer()->SetExternalScrollOffsetListener(NULL);
+    InnerViewportScrollLayer()->SetCurrentScrollOffset(root_offset);
+    InnerViewportScrollLayer()->SetExternalScrollOffsetListener(
+        layer_scroll_offset_listener_.get());
+    UpdateRootScrollOffsetDelegate();
+    return;
+  }
 
   // If we get here, we have both inner/outer viewports, and need to distribute
   // the scroll offset between them.
-  DCHECK(inner_viewport_scroll_delegate_proxy_);
-  DCHECK(outer_viewport_scroll_delegate_proxy_);
+  // It is okay for inner and outer viewport scroll layer to have no scroll
+  // delegate at this time.
   gfx::ScrollOffset inner_viewport_offset =
-      inner_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
+      InnerViewportScrollLayer()->CurrentScrollOffset();
   gfx::ScrollOffset outer_viewport_offset =
-      outer_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
+      OuterViewportScrollLayer()->CurrentScrollOffset();
 
   // It may be nothing has changed.
-  gfx::ScrollOffset delegate_offset =
-      root_layer_scroll_offset_delegate_->GetTotalScrollOffset();
-  if (inner_viewport_offset + outer_viewport_offset == delegate_offset) {
-    if (layer == InnerViewportScrollLayer())
-      return inner_viewport_offset;
-    else
-      return outer_viewport_offset;
-  }
+  if (inner_viewport_offset + outer_viewport_offset == root_offset)
+    return;
+
+  // Temporarily uninstall the scroll offset listeners so that the root scroll
+  // offset delegate is not thrashed back and forth when the inner and outer
+  // viewport scroll layer change their scroll offsets.
+  InnerViewportScrollLayer()->SetExternalScrollOffsetListener(NULL);
+  OuterViewportScrollLayer()->SetExternalScrollOffsetListener(NULL);
 
   gfx::ScrollOffset max_outer_viewport_scroll_offset =
       OuterViewportScrollLayer()->MaxScrollOffset();
 
-  outer_viewport_offset = delegate_offset - inner_viewport_offset;
+  outer_viewport_offset = root_offset - inner_viewport_offset;
   outer_viewport_offset.SetToMin(max_outer_viewport_scroll_offset);
   outer_viewport_offset.SetToMax(gfx::ScrollOffset());
 
-  if (layer == OuterViewportScrollLayer())
-    return outer_viewport_offset;
+  OuterViewportScrollLayer()->SetCurrentScrollOffset(outer_viewport_offset);
+  inner_viewport_offset = root_offset - outer_viewport_offset;
+  InnerViewportScrollLayer()->SetCurrentScrollOffset(inner_viewport_offset);
 
-  inner_viewport_offset = delegate_offset - outer_viewport_offset;
+  InnerViewportScrollLayer()->SetExternalScrollOffsetListener(
+      layer_scroll_offset_listener_.get());
+  OuterViewportScrollLayer()->SetExternalScrollOffsetListener(
+      layer_scroll_offset_listener_.get());
 
-  return inner_viewport_offset;
+  UpdateRootScrollOffsetDelegate();
 }
 
 void LayerTreeImpl::QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise) {
   DCHECK(swap_promise);
   swap_promise_list_.push_back(swap_promise.Pass());
 }
 
 void LayerTreeImpl::PassSwapPromises(
     ScopedPtrVector<SwapPromise>* new_swap_promise) {
   swap_promise_list_.insert_and_take(swap_promise_list_.end(),
@@ skipping 486 matching lines @@
     scoped_ptr<PendingPageScaleAnimation> pending_animation) {
   pending_page_scale_animation_ = pending_animation.Pass();
 }
 
 scoped_ptr<PendingPageScaleAnimation>
     LayerTreeImpl::TakePendingPageScaleAnimation() {
   return pending_page_scale_animation_.Pass();
 }
 
 }  // namespace cc