Overscroll and Elasticity for views::ScrollView

cc/trees/property_tree.cc

Index: cc/trees/property_tree.cc
diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index 4f2c950bf333125e0f3a0e44fd03ab079242d0e8..53c355feabdcdba8ccdd01d461764ed7acda5ea5 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -545,10 +545,11 @@ void TransformTree::UpdateLocalTransform(TransformNode* node) {
   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);
@@ -1248,6 +1249,11 @@ void EffectTree::FromProtobuf(
   }
 }
 
+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()) {}
@@ -1268,15 +1274,16 @@ ScrollTree& ScrollTree::operator=(const ScrollTree& from) {
 }
 
 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;
   }
 
@@ -1294,13 +1301,15 @@ void ScrollTree::ToProtobuf(proto::PropertyTree* proto) const {
   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());
   }
 }
 
@@ -1321,10 +1330,11 @@ void ScrollTree::FromProtobuf(
   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());
   }
 }
 
@@ -1340,7 +1350,7 @@ void ScrollTree::clear() {
   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
@@ -1453,27 +1463,43 @@ gfx::Transform ScrollTree::ScreenSpaceTransform(int scroll_node_id) const {
   return screen_space_transform;
 }
 
-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;
+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 layer_id_to_scroll_offset_map_[layer_id].get();
+  return &it->second;
 }
 
-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()) {
+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 layer_id_to_scroll_offset_map_.at(layer_id).get();
+  return &it->second;
+}
+
+SyncedScrollOffset* ScrollTree::synced_scroll_offset(int layer_id) {
+  return GetOrCreate(layer_id)->synced_offset.get();
+}
+
+const SyncedScrollOffset* ScrollTree::synced_scroll_offset(int layer_id) const {
+  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(
@@ -1497,64 +1523,73 @@ gfx::ScrollOffset ScrollTree::PullDeltaForMainThread(
 
 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();
@@ -1577,32 +1612,41 @@ void ScrollTree::UpdateScrollOffsetMap(
   }
 }
 
-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(
@@ -1674,7 +1718,8 @@ gfx::Vector2dF ScrollTree::ScrollBy(ScrollNode* scroll_node,
   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 =
@@ -1833,8 +1878,9 @@ void PropertyTrees::clear() {
   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());