Adding momentum/overscroll to views:: ScrollViews

cc/trees/property_tree.h

 // 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.
 
 #ifndef CC_TREES_PROPERTY_TREE_H_
 #define CC_TREES_PROPERTY_TREE_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 335 matching lines @@
   std::unordered_multimap<int, std::unique_ptr<CopyOutputRequest>>
       copy_requests_;
 
   // Unsorted list of all mask, replica, and replica mask layer ids that
   // effect nodes refer to.
   std::vector<int> mask_replica_layer_ids_;
 };
 
 class CC_EXPORT ScrollTree final : public PropertyTree<ScrollNode> {
  public:
+  struct ScrollWithOverscroll;
+
   ScrollTree();
   ~ScrollTree();
 
   ScrollTree& operator=(const ScrollTree& from);
   bool operator==(const ScrollTree& other) const;
 
   void ToProtobuf(proto::PropertyTree* proto) const;
   void FromProtobuf(const proto::PropertyTree& proto,
                     std::unordered_map<int, int>* node_id_to_index_map);
 
   void clear();
 
-  typedef std::unordered_map<int, scoped_refptr<SyncedScrollOffset>>
-      ScrollOffsetMap;
+  typedef std::unordered_map<int, ScrollWithOverscroll> ScrollOffsetMap;
 
   gfx::ScrollOffset MaxScrollOffset(int scroll_node_id) const;
   gfx::Size scroll_clip_layer_bounds(int scroll_node_id) const;
   ScrollNode* CurrentlyScrollingNode();
   const ScrollNode* CurrentlyScrollingNode() const;
   void set_currently_scrolling_node(int scroll_node_id);
   gfx::Transform ScreenSpaceTransform(int scroll_node_id) const;
 
   const gfx::ScrollOffset current_scroll_offset(int layer_id) const;
+  const gfx::ScrollOffset current_overscroll(int layer_id) const;
   void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
                            int inner_viewport_layer_id);
-  void UpdateScrollOffsetMap(ScrollOffsetMap* new_scroll_offset_map,
+  void UpdateScrollOffsetMap(ScrollTree* scroll_tree,
                              LayerTreeImpl* layer_tree_impl);
-  ScrollOffsetMap& scroll_offset_map();
-  const ScrollOffsetMap& scroll_offset_map() const;
+  const ScrollOffsetMap& scroll_offset_map_for_test() const;
   void ApplySentScrollDeltasFromAbortedCommit();
-  bool SetBaseScrollOffset(int layer_id,
-                           const gfx::ScrollOffset& scroll_offset);
-  bool SetScrollOffset(int layer_id, const gfx::ScrollOffset& scroll_offset);
-  void SetScrollOffsetClobberActiveValue(int layer_id) {
-    synced_scroll_offset(layer_id)->set_clobber_active_value();
+  void SetBaseScrollOffset(int layer_id,
+                           const gfx::ScrollOffset& scroll_offset,
+                           const gfx::ScrollOffset& overscroll);
+  bool SetScrollOffset(int layer_id,
+                       const gfx::ScrollOffset& scroll_offset,
+                       const gfx::ScrollOffset& overscroll);
+
+  // TODO(tapted): Remove this overload (used by TreeSynchronizerTest).
+  bool SetScrollOffset(int layer_id, const gfx::ScrollOffset& scroll_offset) {
+    return SetScrollOffset(layer_id, scroll_offset, gfx::ScrollOffset());
   }
+
+  void SetScrollOffsetClobberActiveValue(int layer_id);
   bool UpdateScrollOffsetBaseForTesting(int layer_id,
                                         const gfx::ScrollOffset& offset);
   bool SetScrollOffsetDeltaForTesting(int layer_id,
                                       const gfx::Vector2dF& delta);
   const gfx::ScrollOffset GetScrollOffsetBaseForTesting(int layer_id) const;
   const gfx::ScrollOffset GetScrollOffsetDeltaForTesting(int layer_id) const;
   void CollectScrollDeltasForTesting();
 
   void DistributeScroll(ScrollNode* scroll_node, ScrollState* scroll_state);
   gfx::Vector2dF ScrollBy(ScrollNode* scroll_node,
                           const gfx::Vector2dF& scroll,
                           LayerTreeImpl* layer_tree_impl);
   gfx::ScrollOffset ClampScrollOffsetToLimits(gfx::ScrollOffset offset,
                                               ScrollNode* scroll_node) const;
 
  private:
   int currently_scrolling_node_id_;
   ScrollOffsetMap layer_id_to_scroll_offset_map_;
 
+  ScrollWithOverscroll* GetOrCreate(int layer_id);
+  const ScrollWithOverscroll* GetOrNull(int layer_id) const;
   SyncedScrollOffset* synced_scroll_offset(int layer_id);
   const SyncedScrollOffset* synced_scroll_offset(int layer_id) const;
+
   gfx::ScrollOffset PullDeltaForMainThread(SyncedScrollOffset* scroll_offset);
   void UpdateScrollOffsetMapEntry(int key,
                                   ScrollOffsetMap* new_scroll_offset_map,
                                   LayerTreeImpl* layer_tree_impl);
 };
 
+// Required in the header for TreeSynchronizerTest.
+struct ScrollTree::ScrollWithOverscroll {
+  scoped_refptr<SyncedScrollOffset> synced_offset;
+  gfx::ScrollOffset overscroll;
+
+  // Hide the copy constructor to prevent inefficient map iterations, but then
+  // the map needs a move constructor to insert items.
+  ScrollWithOverscroll();
+  ScrollWithOverscroll(const ScrollWithOverscroll& rhs) = delete;
+  ScrollWithOverscroll(ScrollWithOverscroll&& rhs);
+  ~ScrollWithOverscroll();
+
+  bool operator==(const ScrollWithOverscroll& rhs) const {
+    return synced_offset == rhs.synced_offset && overscroll == rhs.overscroll;
+  }
+  bool operator!=(const ScrollWithOverscroll& rhs) const {
+    return !operator==(rhs);
+  }
+};
+
 struct AnimationScaleData {
   // Variable used to invalidate cached animation scale data when transform tree
   // updates.
   int update_number;
 
   // Current animations, considering only scales at keyframes not including the
   // starting keyframe of each animation.
   float local_maximum_animation_target_scale;
 
   // The maximum scale that this node's |local| transform will have during
@@ skipping 123 matching lines @@
   gfx::Vector2dF inner_viewport_container_bounds_delta_;
   gfx::Vector2dF outer_viewport_container_bounds_delta_;
   gfx::Vector2dF inner_viewport_scroll_bounds_delta_;
 
   PropertyTreesCachedData cached_data_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_