Overscroll and Elasticity for views::ScrollView

cc/layers/layer_impl.cc

 // Copyright 2012 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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 39 matching lines @@
 namespace cc {
 LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
     : layer_id_(id),
       layer_tree_impl_(tree_impl),
       test_properties_(nullptr),
       scroll_clip_layer_id_(Layer::INVALID_ID),
       main_thread_scrolling_reasons_(
           MainThreadScrollingReason::kNotScrollingOnMain),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
+      can_overscroll_(false),
       should_flatten_transform_from_property_tree_(false),
       layer_property_changed_(false),
       may_contain_video_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       use_parent_backface_visibility_(false),
       use_local_transform_for_backface_visibility_(false),
       should_check_backface_visibility_(false),
       draws_content_(false),
       is_drawn_render_surface_layer_list_member_(false),
@@ skipping 210 matching lines @@
   NOTREACHED();
   *resource_id = 0;
 }
 
 gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) {
   ScrollTree& scroll_tree = layer_tree_impl()->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.Node(scroll_tree_index());
   return scroll_tree.ScrollBy(scroll_node, scroll, layer_tree_impl());
 }
 
-void LayerImpl::SetScrollClipLayer(int scroll_clip_layer_id) {
-  if (scroll_clip_layer_id_ == scroll_clip_layer_id)
+void LayerImpl::SetScrollClipAndCanOverscroll(int scroll_clip_layer_id,
+                                              bool can_overscroll) {
+  if (scroll_clip_layer_id_ == scroll_clip_layer_id &&
+      can_overscroll_ == can_overscroll)
     return;
 
   layer_tree_impl()->UnregisterScrollLayer(this);
   scroll_clip_layer_id_ = scroll_clip_layer_id;
+  can_overscroll_ = can_overscroll;
   layer_tree_impl()->RegisterScrollLayer(this);
 }
 
 LayerImpl* LayerImpl::scroll_clip_layer() const {
   return layer_tree_impl()->LayerById(scroll_clip_layer_id_);
 }
 
 bool LayerImpl::scrollable() const {
   return scroll_clip_layer_id_ != Layer::INVALID_ID;
 }
@@ skipping 55 matching lines @@
     layer->layer_property_changed_ = true;
   }
 
   // If whether layer has render surface changes, we need to update draw
   // properties.
   // TODO(weiliangc): Should be safely removed after impl side is able to
   // update render surfaces without rebuilding property trees.
   if (layer->has_render_surface() != has_render_surface())
     layer->layer_tree_impl()->set_needs_update_draw_properties();
   layer->SetBounds(bounds_);
-  layer->SetScrollClipLayer(scroll_clip_layer_id_);
+  layer->SetScrollClipAndCanOverscroll(scroll_clip_layer_id_, can_overscroll_);
   layer->SetElementId(element_id_);
   layer->SetMutableProperties(mutable_properties_);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
 
@@ skipping 444 matching lines @@
   update_rect_ = update_rect;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::AddDamageRect(const gfx::Rect& damage_rect) {
   damage_rect_.Union(damage_rect);
 }
 
 void LayerImpl::SetCurrentScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsActive());
-  if (layer_tree_impl()->property_trees()->scroll_tree.SetScrollOffset(
-          id(), scroll_offset))
+  ScrollTree& scroll_tree = layer_tree_impl()->property_trees()->scroll_tree;
+  if (scroll_tree.SetScrollOffset(id(), scroll_offset, CurrentOverscroll()))
     layer_tree_impl()->DidUpdateScrollOffset(id());
 }
 
 gfx::ScrollOffset LayerImpl::CurrentScrollOffset() const {
   return layer_tree_impl()->property_trees()->scroll_tree.current_scroll_offset(
       id());
 }
 
+void LayerImpl::SetCurrentOverscroll(const gfx::ScrollOffset& overscroll) {
+  ScrollTree& scroll_tree = layer_tree_impl()->property_trees()->scroll_tree;
+  if (scroll_tree.SetScrollOffset(id(), CurrentScrollOffset(), overscroll))
+    layer_tree_impl()->DidUpdateScrollOffset(id());
+}
+
+gfx::ScrollOffset LayerImpl::CurrentOverscroll() const {
+  return layer_tree_impl()->property_trees()->scroll_tree.current_overscroll(
+      id());
+}
+
 void LayerImpl::UpdatePropertyTreeScrollOffset() {
   // TODO(enne): in the future, scrolling should update the scroll tree
   // directly instead of going through layers.
   TransformTree& transform_tree =
       layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* node = transform_tree.Node(transform_tree_index_);
-  gfx::ScrollOffset current_offset = CurrentScrollOffset();
-  if (node->scroll_offset != current_offset) {
-    node->scroll_offset = current_offset;
+  gfx::ScrollOffset current_offset =
+      CurrentScrollOffset() + CurrentOverscroll();
+  if (node->scroll_offset_with_overscroll != current_offset) {
+    node->scroll_offset_with_overscroll = current_offset;
     node->needs_local_transform_update = true;
     transform_tree.set_needs_update(true);
   }
 }
 
 SimpleEnclosedRegion LayerImpl::VisibleOpaqueRegion() const {
   if (contents_opaque())
     return SimpleEnclosedRegion(visible_layer_rect());
   return SimpleEnclosedRegion();
 }
@@ skipping 232 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       ScreenSpaceTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc