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

cc/trees/property_tree.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 524 matching lines @@
   if (node->affected_by_inner_viewport_bounds_delta_x)
     fixed_position_adjustment.set_x(inner_viewport_bounds_delta.x());
   else if (node->affected_by_outer_viewport_bounds_delta_x)
     fixed_position_adjustment.set_x(outer_viewport_bounds_delta.x());
 
   if (node->affected_by_inner_viewport_bounds_delta_y)
     fixed_position_adjustment.set_y(inner_viewport_bounds_delta.y());
   else if (node->affected_by_outer_viewport_bounds_delta_y)
     fixed_position_adjustment.set_y(outer_viewport_bounds_delta.y());
 
-  transform.Translate(node->source_to_parent.x() - node->scroll_offset.x() +
-                          fixed_position_adjustment.x(),
-                      node->source_to_parent.y() - node->scroll_offset.y() +
-                          fixed_position_adjustment.y());
+  transform.Translate(
+      node->source_to_parent.x() - node->scroll_offset_with_overscroll.x() +
+          fixed_position_adjustment.x(),
+      node->source_to_parent.y() - node->scroll_offset_with_overscroll.y() +
+          fixed_position_adjustment.y());
   transform.Translate(StickyPositionOffset(this, node));
   transform.PreconcatTransform(node->local);
   transform.PreconcatTransform(node->pre_local);
 
   node->set_to_parent(transform);
   node->needs_local_transform_update = false;
 }
 
 void TransformTree::UpdateScreenSpaceTransform(TransformNode* node,
                                                TransformNode* parent_node,
@@ skipping 729 matching lines @@
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
   const proto::EffectTreeData& data = proto.effect_tree_data();
 
   DCHECK(mask_layer_ids_.empty());
   for (int i = 0; i < data.mask_layer_ids_size(); ++i) {
     mask_layer_ids_.push_back(data.mask_layer_ids(i));
   }
 }
 
+ScrollTree::ScrollWithOverscroll::ScrollWithOverscroll() {}
+ScrollTree::ScrollWithOverscroll::ScrollWithOverscroll(
+    ScrollWithOverscroll&& rhs) = default;
+ScrollTree::ScrollWithOverscroll::~ScrollWithOverscroll() {}
+
 ScrollTree::ScrollTree()
     : currently_scrolling_node_id_(kInvalidNodeId),
       layer_id_to_scroll_offset_map_(ScrollTree::ScrollOffsetMap()) {}
 
 ScrollTree::~ScrollTree() {}
 
 ScrollTree& ScrollTree::operator=(const ScrollTree& from) {
   PropertyTree::operator=(from);
   currently_scrolling_node_id_ = kInvalidNodeId;
   // layer_id_to_scroll_offset_map_ is intentionally omitted in operator=,
   // because we do not want to simply copy the map when property tree is
   // propagating from pending to active.
   // In the main to pending case, we do want to copy it, but this can be done by
   // calling UpdateScrollOffsetMap after the assignment;
   // In the other case, we want pending and active property trees to share the
   // same map.
   return *this;
 }
 
 bool ScrollTree::operator==(const ScrollTree& other) const {
-  const ScrollTree::ScrollOffsetMap& other_scroll_offset_map =
-      other.scroll_offset_map();
+  const ScrollOffsetMap& other_scroll_offset_map =
+      other.layer_id_to_scroll_offset_map_;
   if (layer_id_to_scroll_offset_map_.size() != other_scroll_offset_map.size())
     return false;
 
-  for (auto map_entry : layer_id_to_scroll_offset_map_) {
+  for (const auto& map_entry : layer_id_to_scroll_offset_map_) {
     int key = map_entry.first;
-    if (other_scroll_offset_map.find(key) == other_scroll_offset_map.end() ||
-        map_entry.second != layer_id_to_scroll_offset_map_.at(key))
+    auto other_entry_it = other_scroll_offset_map.find(key);
+    if (other_entry_it == other_scroll_offset_map.end() ||
+        map_entry.second != other_entry_it->second)
       return false;
   }
 
   bool is_currently_scrolling_node_equal =
       currently_scrolling_node_id_ == other.currently_scrolling_node_id_;
 
   return PropertyTree::operator==(other) && is_currently_scrolling_node_equal;
 }
 
 void ScrollTree::ToProtobuf(proto::PropertyTree* proto) const {
   DCHECK(!proto->has_property_type());
   proto->set_property_type(proto::PropertyTree::Scroll);
 
   PropertyTree::ToProtobuf(proto);
   proto::ScrollTreeData* data = proto->mutable_scroll_tree_data();
 
   data->set_currently_scrolling_node_id(currently_scrolling_node_id_);
-  for (auto i : layer_id_to_scroll_offset_map_) {
+  for (const auto& i : layer_id_to_scroll_offset_map_) {
     data->add_layer_id_to_scroll_offset_map();
     proto::ScrollOffsetMapEntry* entry =
         data->mutable_layer_id_to_scroll_offset_map(
             data->layer_id_to_scroll_offset_map_size() - 1);
     entry->set_layer_id(i.first);
-    SyncedScrollOffsetToProto(*i.second.get(), entry->mutable_scroll_offset());
+    SyncedScrollOffsetToProto(*i.second.synced_offset.get(),
+                              entry->mutable_scroll_offset());
+    ScrollOffsetToProto(i.second.overscroll, entry->mutable_overscroll());
   }
 }
 
 void ScrollTree::FromProtobuf(
     const proto::PropertyTree& proto,
     std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Scroll);
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
   const proto::ScrollTreeData& data = proto.scroll_tree_data();
 
   currently_scrolling_node_id_ = data.currently_scrolling_node_id();
 
   // TODO(khushalsagar): This should probably be removed if the copy constructor
   // for ScrollTree copies the |layer_id_to_scroll_offset_map_| as well.
   layer_id_to_scroll_offset_map_.clear();
   for (int i = 0; i < data.layer_id_to_scroll_offset_map_size(); ++i) {
     const proto::ScrollOffsetMapEntry entry =
         data.layer_id_to_scroll_offset_map(i);
-    layer_id_to_scroll_offset_map_[entry.layer_id()] = new SyncedScrollOffset();
-    ProtoToSyncedScrollOffset(
-        entry.scroll_offset(),
-        layer_id_to_scroll_offset_map_[entry.layer_id()].get());
+    ScrollWithOverscroll* scroll = GetOrCreate(entry.layer_id());
+    scroll->synced_offset = new SyncedScrollOffset();
+    ProtoToSyncedScrollOffset(entry.scroll_offset(),
+                              scroll->synced_offset.get());
+    scroll->overscroll = ProtoToScrollOffset(entry.overscroll());
   }
 }
 
 void ScrollTree::clear() {
   PropertyTree<ScrollNode>::clear();
 
   if (property_trees()->is_main_thread) {
     currently_scrolling_node_id_ = kInvalidNodeId;
     layer_id_to_scroll_offset_map_.clear();
   }
 
 #if DCHECK_IS_ON()
   ScrollTree tree;
   if (!property_trees()->is_main_thread) {
     tree.currently_scrolling_node_id_ = currently_scrolling_node_id_;
-    tree.layer_id_to_scroll_offset_map_ = layer_id_to_scroll_offset_map_;
+    // tree.layer_id_to_scroll_offset_map_ = layer_id_to_scroll_offset_map_;
   }
   DCHECK(tree == *this);
 #endif
 }
 
 gfx::ScrollOffset ScrollTree::MaxScrollOffset(int scroll_node_id) const {
   const ScrollNode* scroll_node = Node(scroll_node_id);
   gfx::SizeF scroll_bounds =
       gfx::SizeF(scroll_node->bounds.width(), scroll_node->bounds.height());
 
@@ skipping 92 matching lines @@
   gfx::Transform screen_space_transform(
       1, 0, 0, 1, scroll_node->offset_to_transform_parent.x(),
       scroll_node->offset_to_transform_parent.y());
   screen_space_transform.ConcatTransform(
       transform_tree.ToScreen(transform_node->id));
   if (scroll_node->should_flatten)
     screen_space_transform.FlattenTo2d();
   return screen_space_transform;
 }
 
+ScrollTree::ScrollWithOverscroll* ScrollTree::GetOrCreate(int layer_id) {
+  auto it = layer_id_to_scroll_offset_map_.find(layer_id);
+  if (it == layer_id_to_scroll_offset_map_.end()) {
+    it =
+        layer_id_to_scroll_offset_map_.emplace(layer_id, ScrollWithOverscroll())
+            .first;
+    it->second.synced_offset = new SyncedScrollOffset;
+  }
+  return &it->second;
+}
+
+const ScrollTree::ScrollWithOverscroll* ScrollTree::GetOrNull(
+    int layer_id) const {
+  auto it = layer_id_to_scroll_offset_map_.find(layer_id);
+  if (it == layer_id_to_scroll_offset_map_.end())
+    return nullptr;
+  return &it->second;
+}
+
 SyncedScrollOffset* ScrollTree::synced_scroll_offset(int layer_id) {
-  if (layer_id_to_scroll_offset_map_.find(layer_id) ==
-      layer_id_to_scroll_offset_map_.end()) {
-    layer_id_to_scroll_offset_map_[layer_id] = new SyncedScrollOffset;
-  }
-  return layer_id_to_scroll_offset_map_[layer_id].get();
+  return GetOrCreate(layer_id)->synced_offset.get();
 }
 
 const SyncedScrollOffset* ScrollTree::synced_scroll_offset(int layer_id) const {
-  if (layer_id_to_scroll_offset_map_.find(layer_id) ==
-      layer_id_to_scroll_offset_map_.end()) {
-    return nullptr;
-  }
-  return layer_id_to_scroll_offset_map_.at(layer_id).get();
+  const ScrollWithOverscroll* scroll = GetOrNull(layer_id);
+  return scroll ? scroll->synced_offset.get() : nullptr;
 }
 
 const gfx::ScrollOffset ScrollTree::current_scroll_offset(int layer_id) const {
-  return synced_scroll_offset(layer_id)
-             ? synced_scroll_offset(layer_id)->Current(
-                   property_trees()->is_active)
-             : gfx::ScrollOffset();
+  const ScrollWithOverscroll* scroll = GetOrNull(layer_id);
+  return scroll ? scroll->synced_offset->Current(property_trees()->is_active)
+                : gfx::ScrollOffset();
+}
+
+const gfx::ScrollOffset ScrollTree::current_overscroll(int layer_id) const {
+  const ScrollWithOverscroll* scroll = GetOrNull(layer_id);
+  return scroll ? scroll->overscroll : gfx::ScrollOffset();
 }
 
 gfx::ScrollOffset ScrollTree::PullDeltaForMainThread(
     SyncedScrollOffset* scroll_offset) {
   // TODO(miletus): Remove all this temporary flooring machinery when
   // Blink fully supports fractional scrolls.
   gfx::ScrollOffset current_offset =
       scroll_offset->Current(property_trees()->is_active);
   gfx::ScrollOffset current_delta = property_trees()->is_active
                                         ? scroll_offset->Delta()
                                         : scroll_offset->PendingDelta().get();
   gfx::ScrollOffset floored_delta(floor(current_delta.x()),
                                   floor(current_delta.y()));
   gfx::ScrollOffset diff_delta = floored_delta - current_delta;
   gfx::ScrollOffset tmp_offset = current_offset + diff_delta;
   scroll_offset->SetCurrent(tmp_offset);
   gfx::ScrollOffset delta = scroll_offset->PullDeltaForMainThread();
   scroll_offset->SetCurrent(current_offset);
   return delta;
 }
 
 void ScrollTree::CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
                                      int inner_viewport_layer_id) {
-  for (auto map_entry : layer_id_to_scroll_offset_map_) {
+  for (const auto& map_entry : layer_id_to_scroll_offset_map_) {
     gfx::ScrollOffset scroll_delta =
-        PullDeltaForMainThread(map_entry.second.get());
-
+        PullDeltaForMainThread(map_entry.second.synced_offset.get());
+    gfx::ScrollOffset overscroll = map_entry.second.overscroll;
     gfx::Vector2d scroll_delta_vector(scroll_delta.x(), scroll_delta.y());
     int layer_id = map_entry.first;
 
-    if (!scroll_delta.IsZero()) {
+    if (!scroll_delta.IsZero() || !overscroll.IsZero()) {
       if (layer_id == inner_viewport_layer_id) {
         // Inner (visual) viewport is stored separately.
         scroll_info->inner_viewport_scroll.layer_id = layer_id;
         scroll_info->inner_viewport_scroll.scroll_delta = scroll_delta_vector;
+        scroll_info->inner_viewport_scroll.overscroll = overscroll;
       } else {
         LayerTreeHostCommon::ScrollUpdateInfo scroll;
         scroll.layer_id = layer_id;
         scroll.scroll_delta = scroll_delta_vector;
-        scroll_info->scrolls.push_back(scroll);
+        scroll.overscroll = overscroll;
+        scroll_info->scrolls.push_back(std::move(scroll));
       }
     }
   }
 }
 
 void ScrollTree::CollectScrollDeltasForTesting() {
-  for (auto map_entry : layer_id_to_scroll_offset_map_) {
-    PullDeltaForMainThread(map_entry.second.get());
+  for (const auto& map_entry : layer_id_to_scroll_offset_map_) {
+    PullDeltaForMainThread(map_entry.second.synced_offset.get());
   }
 }
 
 void ScrollTree::UpdateScrollOffsetMapEntry(
     int key,
-    ScrollTree::ScrollOffsetMap* new_scroll_offset_map,
+    ScrollOffsetMap* new_scroll_offset_map,
     LayerTreeImpl* layer_tree_impl) {
   bool changed = false;
   // If we are pushing scroll offset from main to pending tree, we create a new
   // instance of synced scroll offset; if we are pushing from pending to active,
   // we reuse the pending tree's value in the map.
+  ScrollWithOverscroll& other_scroll = new_scroll_offset_map->at(key);
   if (!property_trees()->is_active) {
-    changed = synced_scroll_offset(key)->PushFromMainThread(
-        new_scroll_offset_map->at(key)->PendingBase());
+    ScrollWithOverscroll& this_scroll = *GetOrCreate(key);
+    changed = this_scroll.synced_offset->PushFromMainThread(
+        other_scroll.synced_offset->PendingBase());
 
-    if (new_scroll_offset_map->at(key)->clobber_active_value()) {
-      synced_scroll_offset(key)->set_clobber_active_value();
+    if (other_scroll.synced_offset->clobber_active_value()) {
+      this_scroll.synced_offset->set_clobber_active_value();
     }
+    changed |= this_scroll.overscroll != other_scroll.overscroll;
+    this_scroll.overscroll = other_scroll.overscroll;
     if (changed) {
       layer_tree_impl->DidUpdateScrollOffset(key);
     }
   } else {
-    layer_id_to_scroll_offset_map_[key] = new_scroll_offset_map->at(key);
-    changed |= synced_scroll_offset(key)->PushPendingToActive();
+    ScrollWithOverscroll& this_scroll = layer_id_to_scroll_offset_map_[key];
+    this_scroll.synced_offset = other_scroll.synced_offset;
+    // Nothing to do for overscroll.
+    changed |= this_scroll.synced_offset->PushPendingToActive();
     if (changed) {
       layer_tree_impl->DidUpdateScrollOffset(key);
     }
   }
 }
 
-void ScrollTree::UpdateScrollOffsetMap(
-    ScrollTree::ScrollOffsetMap* new_scroll_offset_map,
-    LayerTreeImpl* layer_tree_impl) {
+void ScrollTree::UpdateScrollOffsetMap(ScrollTree* scroll_tree,
+                                       LayerTreeImpl* layer_tree_impl) {
+  ScrollOffsetMap* new_scroll_offset_map =
+      &scroll_tree->layer_id_to_scroll_offset_map_;
   if (layer_tree_impl && !layer_tree_impl->LayerListIsEmpty()) {
     DCHECK(!property_trees()->is_main_thread);
     for (auto map_entry = layer_id_to_scroll_offset_map_.begin();
          map_entry != layer_id_to_scroll_offset_map_.end();) {
       int key = map_entry->first;
       if (new_scroll_offset_map->find(key) != new_scroll_offset_map->end()) {
         UpdateScrollOffsetMapEntry(key, new_scroll_offset_map, layer_tree_impl);
         ++map_entry;
       } else {
         map_entry = layer_id_to_scroll_offset_map_.erase(map_entry);
       }
     }
 
     for (auto& map_entry : *new_scroll_offset_map) {
       int key = map_entry.first;
       if (layer_id_to_scroll_offset_map_.find(key) ==
           layer_id_to_scroll_offset_map_.end())
         UpdateScrollOffsetMapEntry(key, new_scroll_offset_map, layer_tree_impl);
     }
   }
 }
 
-ScrollTree::ScrollOffsetMap& ScrollTree::scroll_offset_map() {
-  return layer_id_to_scroll_offset_map_;
-}
-
-const ScrollTree::ScrollOffsetMap& ScrollTree::scroll_offset_map() const {
+const ScrollTree::ScrollOffsetMap& ScrollTree::scroll_offset_map_for_test()
+    const {
   return layer_id_to_scroll_offset_map_;
 }
 
 void ScrollTree::ApplySentScrollDeltasFromAbortedCommit() {
   DCHECK(property_trees()->is_active);
   for (auto& map_entry : layer_id_to_scroll_offset_map_)
-    map_entry.second->AbortCommit();
+    map_entry.second.synced_offset->AbortCommit();
 }
 
-bool ScrollTree::SetBaseScrollOffset(int layer_id,
-                                     const gfx::ScrollOffset& scroll_offset) {
-  return synced_scroll_offset(layer_id)->PushFromMainThread(scroll_offset);
+void ScrollTree::SetBaseScrollOffset(int layer_id,
+                                     const gfx::ScrollOffset& scroll_offset,
+                                     const gfx::ScrollOffset& overscroll) {
+  ScrollWithOverscroll* scroll = GetOrCreate(layer_id);
+  scroll->overscroll = overscroll;
+  scroll->synced_offset->PushFromMainThread(scroll_offset);
 }
 
 bool ScrollTree::SetScrollOffset(int layer_id,
-                                 const gfx::ScrollOffset& scroll_offset) {
+                                 const gfx::ScrollOffset& scroll_offset,
+                                 const gfx::ScrollOffset& overscroll) {
+  ScrollWithOverscroll* scroll = GetOrCreate(layer_id);
+  bool change = scroll->overscroll != overscroll;
+  scroll->overscroll = overscroll;
+
   if (property_trees()->is_main_thread)
-    return synced_scroll_offset(layer_id)->PushFromMainThread(scroll_offset);
+    change |= synced_scroll_offset(layer_id)->PushFromMainThread(scroll_offset);
   else if (property_trees()->is_active)
-    return synced_scroll_offset(layer_id)->SetCurrent(scroll_offset);
-  return false;
+    change |= synced_scroll_offset(layer_id)->SetCurrent(scroll_offset);
+  return change;
+}
+
+void ScrollTree::SetScrollOffsetClobberActiveValue(int layer_id) {
+  GetOrCreate(layer_id)->synced_offset->set_clobber_active_value();
 }
 
 bool ScrollTree::UpdateScrollOffsetBaseForTesting(
     int layer_id,
     const gfx::ScrollOffset& offset) {
   DCHECK(!property_trees()->is_main_thread);
   bool changed = synced_scroll_offset(layer_id)->PushFromMainThread(offset);
   if (property_trees()->is_active)
     changed |= synced_scroll_offset(layer_id)->PushPendingToActive();
   return changed;
@@ skipping 51 matching lines @@
                                     LayerTreeImpl* layer_tree_impl) {
   gfx::ScrollOffset adjusted_scroll(scroll);
   if (!scroll_node->user_scrollable_horizontal)
     adjusted_scroll.set_x(0);
   if (!scroll_node->user_scrollable_vertical)
     adjusted_scroll.set_y(0);
   DCHECK(scroll_node->scrollable);
   gfx::ScrollOffset old_offset = current_scroll_offset(scroll_node->owner_id);
   gfx::ScrollOffset new_offset =
       ClampScrollOffsetToLimits(old_offset + adjusted_scroll, scroll_node);
-  if (SetScrollOffset(scroll_node->owner_id, new_offset))
+  gfx::ScrollOffset overscroll = current_overscroll(scroll_node->owner_id);
+  if (SetScrollOffset(scroll_node->owner_id, new_offset, overscroll))
     layer_tree_impl->DidUpdateScrollOffset(scroll_node->owner_id);
 
   gfx::ScrollOffset unscrolled =
       old_offset + gfx::ScrollOffset(scroll) - new_offset;
   return gfx::Vector2dF(unscrolled.x(), unscrolled.y());
 }
 
 gfx::ScrollOffset ScrollTree::ClampScrollOffsetToLimits(
     gfx::ScrollOffset offset,
     ScrollNode* scroll_node) const {
@@ skipping 144 matching lines @@
   non_root_surfaces_enabled = true;
 
 #if DCHECK_IS_ON()
   PropertyTrees tree;
   tree.transform_tree = transform_tree;
   tree.effect_tree = effect_tree;
   tree.clip_tree = clip_tree;
   tree.scroll_tree = scroll_tree;
   // Scroll offset map and currently scrolling node id may not be copied
   // during operator=.
-  ScrollTree::ScrollOffsetMap& map = tree.scroll_tree.scroll_offset_map();
-  map = scroll_tree.scroll_offset_map();
+  // ScrollTree::ScrollOffsetMap& map =
+  // tree.scroll_tree.scroll_offset_map_for_test();
+  // map = scroll_tree.scroll_offset_map();
   tree.scroll_tree.set_currently_scrolling_node(
       scroll_tree.CurrentlyScrollingNodeId());
 
   tree.sequence_number = sequence_number;
   tree.is_main_thread = is_main_thread;
   tree.is_active = is_active;
   DCHECK(tree == *this);
 #endif
 }
 
@@ skipping 464 matching lines @@
     from_target.ConcatTransform(draw_transforms.from_target);
     from_target.Scale(effect_node->surface_contents_scale.x(),
                       effect_node->surface_contents_scale.y());
     DCHECK(from_target.ApproximatelyEqual(*transform) ||
            !draw_transforms.invertible);
   }
   return success;
 }
 
 }  // namespace cc