[not for review - epic CL] Adding Elastic+Momentum+Layered scrolling to 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 764 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_host_->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_host_->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 {
   return layer_tree_host()->LayerById(inputs_.scroll_clip_layer_id);
 }
 
 void Layer::SetUserScrollable(bool horizontal, bool vertical) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.user_scrollable_horizontal == horizontal &&
@@ skipping 307 matching lines @@
       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_);
   if (!TransformIsAnimating())
     layer->SetTransform(inputs_.transform);
   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 203 matching lines @@
   base->set_use_parent_backface_visibility(
       inputs_.use_parent_backface_visibility);
   TransformToProto(inputs_.transform, base->mutable_transform());
   base->set_sorting_context_id(inputs_.sorting_context_id);
   base->set_num_descendants_that_draw_content(
       num_descendants_that_draw_content_);
 
   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);
 
   int scroll_parent_id =
       inputs_.scroll_parent ? inputs_.scroll_parent->id() : INVALID_ID;
   base->set_scroll_parent_id(scroll_parent_id);
 
   if (scroll_children_) {
     for (auto* child : *scroll_children_)
       base->add_scroll_children_ids(child->id());
   }
 
   int clip_parent_id =
       inputs_.clip_parent ? inputs_.clip_parent->id() : INVALID_ID;
   base->set_clip_parent_id(clip_parent_id);
 
   if (clip_children_) {
     for (auto* child : *clip_children_)
       base->add_clip_children_ids(child->id());
   }
 
   ScrollOffsetToProto(inputs_.scroll_offset, base->mutable_scroll_offset());
+  ScrollOffsetToProto(inputs_.overscroll, base->mutable_overscroll());
 
   // TODO(nyquist): Figure out what to do with CopyRequests.
   // See crbug.com/570374.
 
   RectToProto(inputs_.update_rect, base->mutable_update_rect());
 
   // TODO(nyquist): Figure out what to do with ElementAnimations.
   // See crbug.com/570376.
 
   inputs_.update_rect = gfx::Rect();
@@ skipping 44 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_host_->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
@@ skipping 22 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_host_->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 336 matching lines @@
       ->num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, TransformTree::kInvalidNodeId);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc