Overscroll and Elasticity for views::ScrollView

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 754 matching lines @@
   DCHECK(IsPropertyChangeAllowed());
 
   if (inputs_.scroll_offset == scroll_offset)
     return;
   inputs_.scroll_offset = scroll_offset;
 
   if (!layer_tree_host_)
     return;
 
   PropertyTrees* property_trees = layer_tree_->property_trees();
-  if (scroll_tree_index() != ScrollTree::kInvalidNodeId && scrollable())
-    property_trees->scroll_tree.SetScrollOffset(id(), scroll_offset);
+  if (scroll_tree_index() != ScrollTree::kInvalidNodeId && scrollable()) {
+    property_trees->scroll_tree.SetScrollOffset(id(), inputs_.scroll_offset,
+                                                inputs_.overscroll);
+  }
 
   if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
                                        id())) {
     DCHECK_EQ(transform_tree_index(),
               property_trees->transform_id_to_index_map[id()]);
     TransformNode* transform_node =
         property_trees->transform_tree.Node(transform_tree_index());
-    transform_node->scroll_offset = CurrentScrollOffset();
+    transform_node->scroll_offset_with_overscroll =
+        inputs_.scroll_offset + inputs_.overscroll;
     transform_node->needs_local_transform_update = true;
     property_trees->transform_tree.set_needs_update(true);
     SetNeedsCommitNoRebuild();
     return;
   }
 
   SetNeedsCommit();
 }
 
-void Layer::SetScrollOffsetFromImplSide(
-    const gfx::ScrollOffset& scroll_offset) {
+void Layer::SetScrollOffsetFromImplSide(const gfx::ScrollOffset& scroll_offset,
+                                        gfx::Vector2dF* overscroll_delta) {
   DCHECK(IsPropertyChangeAllowed());
   // This function only gets called during a BeginMainFrame, so there
   // is no need to call SetNeedsUpdate here.
   DCHECK(layer_tree_host_ && layer_tree_host_->CommitRequested());
-  if (inputs_.scroll_offset == scroll_offset)
+
+  gfx::ScrollOffset overscroll = inputs_.overscroll;
+  if (inputs_.can_overscroll && overscroll_delta) {
+    overscroll = gfx::ScrollOffsetWithDelta(overscroll, *overscroll_delta);
+    *overscroll_delta = gfx::Vector2dF();
+  }
+  if (inputs_.scroll_offset == scroll_offset &&
+      inputs_.overscroll == overscroll)
     return;
+
   inputs_.scroll_offset = scroll_offset;
+  inputs_.overscroll = overscroll;
   SetNeedsPushProperties();
 
   bool needs_rebuild = true;
 
   PropertyTrees* property_trees = layer_tree_->property_trees();
-  if (scroll_tree_index() != ScrollTree::kInvalidNodeId && scrollable())
-    property_trees->scroll_tree.SetScrollOffset(id(), scroll_offset);
+  if (scroll_tree_index() != ScrollTree::kInvalidNodeId && scrollable()) {
+    property_trees->scroll_tree.SetScrollOffset(id(), inputs_.scroll_offset,
+                                                inputs_.overscroll);
+  }
 
   if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
                                        id())) {
     DCHECK_EQ(transform_tree_index(),
               property_trees->transform_id_to_index_map[id()]);
     TransformNode* transform_node =
         property_trees->transform_tree.Node(transform_tree_index());
-    transform_node->scroll_offset = CurrentScrollOffset();
+    transform_node->scroll_offset_with_overscroll =
+        inputs_.scroll_offset + inputs_.overscroll;
     transform_node->needs_local_transform_update = true;
     property_trees->transform_tree.set_needs_update(true);
     needs_rebuild = false;
   }
 
   if (needs_rebuild)
     property_trees->needs_rebuild = true;
 
   if (!inputs_.did_scroll_callback.is_null())
     inputs_.did_scroll_callback.Run();
   // The callback could potentially change the layer structure:
   // "this" may have been destroyed during the process.
 }
 
-void Layer::SetScrollClipLayerId(int clip_layer_id) {
+void Layer::SetScrollClipAndCanOverscroll(int clip_layer_id,
+                                          bool can_overscroll) {
   DCHECK(IsPropertyChangeAllowed());
-  if (inputs_.scroll_clip_layer_id == clip_layer_id)
+  if (inputs_.scroll_clip_layer_id == clip_layer_id &&
+      inputs_.can_overscroll == can_overscroll)
     return;
   inputs_.scroll_clip_layer_id = clip_layer_id;
+  inputs_.can_overscroll = can_overscroll;
   SetNeedsCommit();
 }
 
 Layer* Layer::scroll_clip_layer() const {
   DCHECK(layer_tree_);
   return layer_tree_->LayerById(inputs_.scroll_clip_layer_id);
 }
 
 void Layer::SetUserScrollable(bool horizontal, bool vertical) {
   DCHECK(IsPropertyChangeAllowed());
@@ skipping 311 matching lines @@
   layer->SetPosition(inputs_.position);
   layer->set_should_flatten_transform_from_property_tree(
       should_flatten_transform_from_property_tree_);
   layer->set_draw_blend_mode(draw_blend_mode_);
   layer->SetUseParentBackfaceVisibility(inputs_.use_parent_backface_visibility);
   layer->SetUseLocalTransformForBackfaceVisibility(
       use_local_transform_for_backface_visibility_);
   layer->SetShouldCheckBackfaceVisibility(should_check_backface_visibility_);
   layer->Set3dSortingContextId(inputs_.sorting_context_id);
 
-  layer->SetScrollClipLayer(inputs_.scroll_clip_layer_id);
+  layer->SetScrollClipAndCanOverscroll(inputs_.scroll_clip_layer_id,
+                                       inputs_.can_overscroll);
   layer->set_user_scrollable_horizontal(inputs_.user_scrollable_horizontal);
   layer->set_user_scrollable_vertical(inputs_.user_scrollable_vertical);
   layer->SetElementId(inputs_.element_id);
   layer->SetMutableProperties(inputs_.mutable_properties);
 
   // When a scroll offset animation is interrupted the new scroll position on
   // the pending tree will clobber any impl-side scrolling occuring on the
   // active tree. To do so, avoid scrolling the pending tree along with it
   // instead of trying to undo that scrolling later.
   if (ScrollOffsetAnimationWasInterrupted())
@@ skipping 163 matching lines @@
   TransformToProto(inputs_.transform, base->mutable_transform());
   Point3FToProto(inputs_.transform_origin, base->mutable_transform_origin());
   base->set_is_drawable(inputs_.is_drawable);
   base->set_double_sided(inputs_.double_sided);
   base->set_should_flatten_transform(inputs_.should_flatten_transform);
   base->set_sorting_context_id(inputs_.sorting_context_id);
   base->set_use_parent_backface_visibility(
       inputs_.use_parent_backface_visibility);
   base->set_background_color(inputs_.background_color);
   ScrollOffsetToProto(inputs_.scroll_offset, base->mutable_scroll_offset());
+  ScrollOffsetToProto(inputs_.overscroll, base->mutable_overscroll());
   base->set_scroll_clip_layer_id(inputs_.scroll_clip_layer_id);
   base->set_user_scrollable_horizontal(inputs_.user_scrollable_horizontal);
   base->set_user_scrollable_vertical(inputs_.user_scrollable_vertical);
+  base->set_can_overscroll(inputs_.can_overscroll);
   base->set_main_thread_scrolling_reasons(
       inputs_.main_thread_scrolling_reasons);
   RegionToProto(inputs_.non_fast_scrollable_region,
                 base->mutable_non_fast_scrollable_region());
   RegionToProto(inputs_.touch_event_handler_region,
                 base->mutable_touch_event_handler_region());
   base->set_is_container_for_fixed_position_layers(
       inputs_.is_container_for_fixed_position_layers);
   inputs_.position_constraint.ToProtobuf(base->mutable_position_constraint());
   inputs_.sticky_position_constraint.ToProtobuf(
@@ skipping 115 matching lines @@
   draw_blend_mode_ = SkXfermodeModeFromProto(base.draw_blend_mode());
   inputs_.use_parent_backface_visibility =
       base.use_parent_backface_visibility();
   inputs_.transform = ProtoToTransform(base.transform());
   inputs_.sorting_context_id = base.sorting_context_id();
   num_descendants_that_draw_content_ = base.num_descendants_that_draw_content();
 
   inputs_.scroll_clip_layer_id = base.scroll_clip_layer_id();
   inputs_.user_scrollable_horizontal = base.user_scrollable_horizontal();
   inputs_.user_scrollable_vertical = base.user_scrollable_vertical();
+  inputs_.can_overscroll = base.can_overscroll();
 
   inputs_.scroll_parent = base.scroll_parent_id() == INVALID_ID
                               ? nullptr
                               : layer_tree_->LayerById(base.scroll_parent_id());
 
   // If there have been scroll children entries in previous deserializations,
   // clear out the set. If there have been none, initialize the set of children.
   // After this, the set is in the correct state to only add the new children.
   // If the set of children has not changed, for now this code still rebuilds
   // the set.
@@ skipping 20 matching lines @@
     clip_children_->clear();
   else if (base.clip_children_ids_size() > 0)
     clip_children_.reset(new std::set<Layer*>);
   for (int i = 0; i < base.clip_children_ids_size(); ++i) {
     int child_id = base.clip_children_ids(i);
     scoped_refptr<Layer> child = layer_tree_->LayerById(child_id);
     clip_children_->insert(child.get());
   }
 
   inputs_.scroll_offset = ProtoToScrollOffset(base.scroll_offset());
+  inputs_.overscroll = ProtoToScrollOffset(base.overscroll());
 
   inputs_.update_rect.Union(ProtoToRect(base.update_rect()));
 
   inputs_.has_will_change_transform_hint =
       base.has_will_change_transform_hint();
 }
 
 std::unique_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return LayerImpl::Create(tree_impl, inputs_.layer_id);
 }
@@ skipping 349 matching lines @@
 
 LayerTree* Layer::GetLayerTree() const {
   return layer_tree_;
 }
 
 void Layer::SetLayerIdForTesting(int id) {
   inputs_.layer_id = id;
 }
 
 }  // namespace cc