[not for review - epic CL] Adding Elastic+Momentum+Layered scrolling to views::ScrollView

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 271 matching lines @@
   DCHECK(!resource_provider_);
   DCHECK(!resource_pool_);
   DCHECK(!tile_task_manager_);
   DCHECK(!single_thread_synchronous_task_graph_runner_);
   DCHECK(!image_decode_controller_);
 
   if (input_handler_client_) {
     input_handler_client_->WillShutdown();
     input_handler_client_ = NULL;
   }
-  if (scroll_elasticity_helper_)
-    scroll_elasticity_helper_.reset();
+  root_scroll_elasticity_helper_.reset();
 
   // The layer trees must be destroyed before the layer tree host. We've
   // made a contract with our animation controllers that the animation_host
   // will outlive them, and we must make good.
   if (recycle_tree_)
     recycle_tree_->Shutdown();
   if (pending_tree_)
     pending_tree_->Shutdown();
   active_tree_->Shutdown();
   recycle_tree_ = nullptr;
@@ skipping 302 matching lines @@
   return layer_impl != NULL;
 }
 
 std::unique_ptr<SwapPromiseMonitor>
 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
   return base::WrapUnique(
       new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
 }
 
-ScrollElasticityHelper* LayerTreeHostImpl::CreateScrollElasticityHelper() {
-  DCHECK(!scroll_elasticity_helper_);
+ScrollElasticityHelper* LayerTreeHostImpl::CreateRootScrollElasticityHelper() {
+  DCHECK(!root_scroll_elasticity_helper_);
   if (settings_.enable_elastic_overscroll) {
-    scroll_elasticity_helper_.reset(
+    root_scroll_elasticity_helper_.reset(
         ScrollElasticityHelper::CreateForLayerTreeHostImpl(this));
   }
-  return scroll_elasticity_helper_.get();
+  return root_scroll_elasticity_helper_.get();
+}
+
+base::WeakPtr<ScrollElasticityHelper>
+LayerTreeHostImpl::ScrollElasticityHelperForScrollingLayer() {
+  LayerImpl* scrolling_layer_impl = CurrentlyScrollingLayer();
+  if (!scrolling_layer_impl)
+    return nullptr;
+
+  return ScrollElasticityHelperForId(scrolling_layer_impl->id())->GetWeakPtr();
+}
+
+gfx::ScrollOffset LayerTreeHostImpl::GetScrollOffsetForLayer(int layer_id) {
+  LayerImpl* layer = active_tree()->FindActiveTreeLayerById(layer_id);
+  return layer ? layer->CurrentScrollOffset() : gfx::ScrollOffset();
+}
+
+bool LayerTreeHostImpl::ScrollLayerTo(int layer_id,
+                                      const gfx::ScrollOffset& offset) {
+  LayerImpl* layer = active_tree()->FindActiveTreeLayerById(layer_id);
+  if (!layer)
+    return false;
+
+  layer->ScrollBy(
+      ScrollOffsetToVector2dF(offset - layer->CurrentScrollOffset()));
+  return true;
 }
 
 void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
     std::unique_ptr<SwapPromise> swap_promise) {
   swap_promises_for_main_thread_scroll_update_.push_back(
       std::move(swap_promise));
 }
 
 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
     const LayerImplList& render_surface_layer_list) {
@@ skipping 2000 matching lines @@
   scroll_status.thread = SCROLL_ON_IMPL_THREAD;
   ScrollAnimationAbort(scrolling_layer_impl);
 
   top_controls_manager_->ScrollBegin();
 
   active_tree_->SetCurrentlyScrollingLayer(scrolling_layer_impl);
   // TODO(majidvp): get rid of wheel_scrolling_ and set is_direct_manipulation
   // in input_handler_proxy instead.
   wheel_scrolling_ = IsWheelBasedScroll(type);
   scroll_state->set_is_direct_manipulation(!wheel_scrolling_);
-  // Invoke |DistributeScrollDelta| even with zero delta and velocity to ensure
-  // scroll customization callbacks are invoked.
+  // Invoke |DistributeScrollDelta| even with zero delta and velocity to process
+  // overscroll and ensure scroll customization callbacks are invoked.
   DistributeScrollDelta(scroll_state);
 
   client_->RenewTreePriority();
   RecordCompositorSlowScrollMetric(type, CC_THREAD);
 
   return scroll_status;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::RootScrollBegin(
     ScrollState* scroll_state,
     InputHandler::ScrollInputType type) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::RootScrollBegin");
 
   ClearCurrentlyScrollingLayer();
 
   return ScrollBeginImpl(scroll_state, InnerViewportScrollLayer(), type);
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
     ScrollState* scroll_state,
     InputHandler::ScrollInputType type) {
   ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
 
   ClearCurrentlyScrollingLayer();
 
+  if (!scroll_state->is_beginning()) {
+    DCHECK(scroll_state->is_in_inertial_phase());
+    // When transitioning into a "flick", try to find the layer that was
+    // already scrolling. Without this, a flick may begin after elastic
+    // overscroll moves the scrolling layer out from beneath the event, causing
+    // a failed hit test.
+    LayerImpl* scrolling_layer_impl =
+        active_tree_->LayerById(active_tree_->LastScrolledLayerId());
+    if (scrolling_layer_impl)
+      return ScrollBeginImpl(scroll_state, scrolling_layer_impl, type);
+  }
+
   gfx::Point viewport_point(scroll_state->position_x(),
                             scroll_state->position_y());
 
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
 
   if (layer_impl) {
     LayerImpl* scroll_layer_impl =
@@ skipping 860 matching lines @@
     int scroll_layer_id) const {
   if (InnerViewportScrollLayer() && OuterViewportScrollLayer() &&
       scroll_layer_id == InnerViewportScrollLayer()->id())
     scroll_layer_id = OuterViewportScrollLayer()->id();
   auto i = scrollbar_animation_controllers_.find(scroll_layer_id);
   if (i == scrollbar_animation_controllers_.end())
     return nullptr;
   return i->second.get();
 }
 
+void LayerTreeHostImpl::RegisterScrollElasticityHelper(int scroll_layer_id) {
+  DCHECK(!InnerViewportScrollLayer() ||
+         scroll_layer_id != InnerViewportScrollLayer()->id());
+  DCHECK(!OuterViewportScrollLayer() ||
+         scroll_layer_id != OuterViewportScrollLayer()->id());
+  DCHECK(settings().enable_elastic_overscroll);
+
+  auto& helper = scroll_elasticity_helpers_[scroll_layer_id];
+  if (!helper)
+    helper = active_tree_->CreateScrollElasticityHelper(scroll_layer_id);
+}
+
+void LayerTreeHostImpl::UnregisterScrollElasticityHelper(int scroll_layer_id) {
+  scroll_elasticity_helpers_.erase(scroll_layer_id);
+}
+
+ScrollElasticityHelper* LayerTreeHostImpl::ScrollElasticityHelperForId(
+    int scroll_layer_id) {
+  if (!settings().enable_elastic_overscroll)
+    return nullptr;
+
+  auto i = scroll_elasticity_helpers_.find(scroll_layer_id);
+  if (i != scroll_elasticity_helpers_.end())
+    return i->second.get();
+
+  if (!root_scroll_elasticity_helper_) {
+    root_scroll_elasticity_helper_.reset(
+        ScrollElasticityHelper::CreateForLayerTreeHostImpl(this));
+  }
+  return root_scroll_elasticity_helper_.get();
+}
+
 void LayerTreeHostImpl::PostDelayedScrollbarAnimationTask(
     const base::Closure& task,
     base::TimeDelta delay) {
   client_->PostDelayedAnimationTaskOnImplThread(task, delay);
 }
 
 // TODO(danakj): Make this a return value from the Animate() call instead of an
 // interface on LTHI. (Also, crbug.com/551138.)
 void LayerTreeHostImpl::SetNeedsAnimateForScrollbarAnimation() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::SetNeedsAnimateForScrollbarAnimation");
@@ skipping 489 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc