Overscroll and Elasticity for views::ScrollView

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <iterator>
 #include <limits>
 #include <set>
 
 #include "base/containers/adapters.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/animation_host.h"
 #include "cc/base/histograms.h"
 #include "cc/base/math_util.h"
 #include "cc/base/synced_property.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/input/page_scale_animation.h"
+#include "cc/input/scroll_elasticity_helper.h"
 #include "cc/input/scrollbar_animation_controller.h"
 #include "cc/input/scrollbar_animation_controller_linear_fade.h"
 #include "cc/input/scrollbar_animation_controller_thinning.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/layer_list_iterator.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/layers/scrollbar_layer_impl_base.h"
 #include "cc/output/compositor_frame_sink.h"
@@ skipping 110 matching lines @@
 
 void LayerTreeImpl::DidUpdateScrollOffset(int layer_id) {
   DidUpdateScrollState(layer_id);
   TransformTree& transform_tree = property_trees()->transform_tree;
   ScrollTree& scroll_tree = property_trees()->scroll_tree;
   int transform_id = -1;
 
   // If pending tree topology changed and we still want to notify the pending
   // tree about scroll offset in the active tree, we may not find the
   // corresponding pending layer.
-  if (LayerById(layer_id)) {
+  if (LayerImpl* layer = LayerById(layer_id)) {
     // TODO(sunxd): when we have a layer_id to property_tree index map in
     // property trees, use the transform_id parameter instead of looking for
     // indices from LayerImpls.
-    transform_id = LayerById(layer_id)->transform_tree_index();
+    transform_id = layer->transform_tree_index();
   } else {
     DCHECK(!IsActiveTree());
     return;
   }
 
   if (transform_id != -1) {
     TransformNode* node = transform_tree.Node(transform_id);
-    if (node->scroll_offset != scroll_tree.current_scroll_offset(layer_id)) {
-      node->scroll_offset = scroll_tree.current_scroll_offset(layer_id);
+    gfx::ScrollOffset scroll_offset_with_overscroll =
+        scroll_tree.current_scroll_offset(layer_id) +
+        scroll_tree.current_overscroll(layer_id);
+    if (node->scroll_offset_with_overscroll != scroll_offset_with_overscroll) {
+      node->scroll_offset_with_overscroll = scroll_offset_with_overscroll;
       node->needs_local_transform_update = true;
       transform_tree.set_needs_update(true);
     }
     node->transform_changed = true;
     property_trees()->changed = true;
     set_needs_update_draw_properties();
   }
 
   if (IsActiveTree() && layer_tree_host_impl_->pending_tree())
     layer_tree_host_impl_->pending_tree()->DidUpdateScrollOffset(layer_id);
@@ skipping 425 matching lines @@
   int new_id = layer ? layer->id() : Layer::INVALID_ID;
   int new_scroll_node_id = layer ? layer->scroll_tree_index() : -1;
   if (layer)
     last_scrolled_layer_id_ = new_id;
 
   if (old_id == new_id)
     return;
 
   ScrollbarAnimationController* old_animation_controller =
       layer_tree_host_impl_->ScrollbarAnimationControllerForId(old_id);
+  ScrollElasticityHelper* old_elasticity_helper =
+      layer_tree_host_impl_->ScrollElasticityHelperForId(old_id);
   ScrollbarAnimationController* new_animation_controller =
       layer_tree_host_impl_->ScrollbarAnimationControllerForId(new_id);
+  ScrollElasticityHelper* new_elasticity_helper =
+      layer_tree_host_impl_->ScrollElasticityHelperForId(new_id);
+  if (old_elasticity_helper == new_elasticity_helper)
+    old_elasticity_helper = new_elasticity_helper = nullptr;
 
   if (old_animation_controller)
     old_animation_controller->DidScrollEnd();
+
   scroll_tree.set_currently_scrolling_node(new_scroll_node_id);
+
   if (new_animation_controller)
     new_animation_controller->DidScrollBegin();
 }
 
 void LayerTreeImpl::ClearCurrentlyScrollingLayer() {
   SetCurrentlyScrollingLayer(NULL);
 }
 
 float LayerTreeImpl::ClampPageScaleFactorToLimits(
     float page_scale_factor) const {
@@ skipping 736 matching lines @@
           scroll_layer_id, layer_tree_host_impl_, delay, resize_delay,
           fade_duration, thinning_duration);
     }
     case LayerTreeSettings::NO_ANIMATOR:
       NOTREACHED();
       break;
   }
   return nullptr;
 }
 
+std::unique_ptr<ScrollElasticityHelper>
+LayerTreeImpl::CreateScrollElasticityHelper(int scroll_layer_id) {
+  DCHECK(settings().enable_elastic_overscroll);
+  return ScrollElasticityHelper::CreateForLayer(scroll_layer_id,
+                                                layer_tree_host_impl_);
+}
+
 void LayerTreeImpl::DidAnimateScrollOffset() {
   layer_tree_host_impl_->DidAnimateScrollOffset();
 }
 
 bool LayerTreeImpl::use_gpu_rasterization() const {
   return layer_tree_host_impl_->use_gpu_rasterization();
 }
 
 GpuRasterizationStatus LayerTreeImpl::GetGpuRasterizationStatus() const {
   return layer_tree_host_impl_->gpu_rasterization_status();
@@ skipping 245 matching lines @@
   return scrollbars;
 }
 
 void LayerTreeImpl::RegisterScrollLayer(LayerImpl* layer) {
   if (layer->scroll_clip_layer_id() == Layer::INVALID_ID)
     return;
 
   clip_scroll_map_.insert(
       std::pair<int, int>(layer->scroll_clip_layer_id(), layer->id()));
 
+  bool can_overscroll = layer->can_overscroll();
+  if (can_overscroll && settings().enable_elastic_overscroll &&
+      (layer->user_scrollable_horizontal() ||
+       layer->user_scrollable_vertical())) {
+    layer_tree_host_impl_->RegisterScrollElasticityHelper(layer->id());
+  }
+
   DidUpdateScrollState(layer->id());
 }
 
 void LayerTreeImpl::UnregisterScrollLayer(LayerImpl* layer) {
   if (layer->scroll_clip_layer_id() == Layer::INVALID_ID)
     return;
 
+  layer_tree_host_impl_->UnregisterScrollElasticityHelper(layer->id());
   clip_scroll_map_.erase(layer->scroll_clip_layer_id());
 }
 
 void LayerTreeImpl::AddSurfaceLayer(LayerImpl* layer) {
   DCHECK(std::find(surface_layers_.begin(), surface_layers_.end(), layer) ==
          surface_layers_.end());
   surface_layers_.push_back(layer);
 }
 
 void LayerTreeImpl::RemoveSurfaceLayer(LayerImpl* layer) {
@@ skipping 407 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc