Scrollbar fade animation broken on Android regression resolved.

cc/trees/layer_tree_host_impl.h

 // Copyright 2011 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_LAYER_TREE_HOST_IMPL_H_
 #define CC_TREES_LAYER_TREE_HOST_IMPL_H_
 
 #include <stddef.h>
 
 #include <bitset>
@@ skipping 113 matching lines @@
   virtual void DidCompletePageScaleAnimationOnImplThread() = 0;
 
   // Called when output surface asks for a draw.
   virtual void OnDrawForCompositorFrameSink(
       bool resourceless_software_draw) = 0;
 
  protected:
   virtual ~LayerTreeHostImplClient() {}
 };
 
+// Used to cache scroll related variables that get reset while clearing
+// the currently scrolling layer. Cached values are restored in case of a
+// scrollBegin in inertial phase (fling) to latch the fling to the previously
+// scrolling layer.
+class ScrollStateForFling {

[aelias_OOO_until_Jul13, 2016/10/27 21:48:11]

What's the event sequence that makes this needed?  Is it like ScrollBegin,
ScrollEnd, ScrollBegin[ForFling]?  If possible, I'd prefer we adjust the event
generation so that the ScrollEnd is not produced if it's going to turn into a
fling.

[sahel, 2016/10/27 22:57:06]

Yes, that's the even sequence and it only happens on a touchpad fling.
I spent a long while to try to predict if a fling is going to happen after an
scrollend or not, and wasn't able to do that efficiently.

One way to address this, is keeping scrollends in a queue (debouncing queue or a
new queue) and waiting for some timeout to see if a fling event is received or
not.

After discussions that we had with @tdresser, we decided not to use any queues
(to avoid adding extra latency) and eventually we want the touch scrolls to have
the same sequence and send the scrollend before fling, rather than not sending
it for touchpad.

+ public:
+  ScrollStateForFling() {
+    ScrollStateForFling(Layer::INVALID_ID, false, false, gfx::Vector2dF());
+  }
+  ScrollStateForFling(int scrolling_layer_id,
+                      bool did_lock_scrolling_layer,
+                      bool scroll_affects_scroll_handler,
+                      gfx::Vector2dF accumulated_root_overscroll)
+      : scrolling_layer_id_(scrolling_layer_id),
+        did_lock_scrolling_layer_(did_lock_scrolling_layer),
+        scroll_affects_scroll_handler_(scroll_affects_scroll_handler),
+        accumulated_root_overscroll_(accumulated_root_overscroll) {}
+
+  int scrolling_layer_id() { return scrolling_layer_id_; }
+  bool did_lock_scrolling_layer() { return did_lock_scrolling_layer_; }
+  bool scroll_affects_scroll_handler() {
+    return scroll_affects_scroll_handler_;
+  }
+  gfx::Vector2dF accumulated_root_overscroll() {
+    return accumulated_root_overscroll_;
+  }
+
+ private:
+  int scrolling_layer_id_;
+  bool did_lock_scrolling_layer_;
+  bool scroll_affects_scroll_handler_;
+  gfx::Vector2dF accumulated_root_overscroll_;
+};
+
 // LayerTreeHostImpl owns the LayerImpl trees as well as associated rendering
 // state.
 class CC_EXPORT LayerTreeHostImpl
     : public InputHandler,
       public TileManagerClient,
       public CompositorFrameSinkClient,
       public TopControlsManagerClient,
       public ScrollbarAnimationControllerClient,
       public VideoFrameControllerClient,
       public LayerTreeMutatorClient,
@@ skipping 545 matching lines @@
 
   void ScrollAnimationAbort(LayerImpl* layer_impl);
 
   bool ScrollAnimationUpdateTarget(ScrollNode* scroll_node,
                                    const gfx::Vector2dF& scroll_delta,
                                    base::TimeDelta delayed_by);
 
   void SetCompositorContextVisibility(bool is_visible);
   void SetWorkerContextVisibility(bool is_visible);
 
+  // Cache & restore variables that get reset in ClearCurrentlyScrollingLayer.
+  // This is used to restore the variables' values in a scrollBegin event
+  // that is in inertial phase (a fling) to latch the event to its
+  // corresponding scroller.
+  void CacheScrollStateForFling();
+  void RestoreScrollStateForFling();
+
   using UIResourceMap = std::unordered_map<UIResourceId, UIResourceData>;
   UIResourceMap ui_resource_map_;
 
   // Resources that were evicted by EvictAllUIResources. Resources are removed
   // from this when they are touched by a create or destroy from the UI resource
   // request queue.
   std::set<UIResourceId> evicted_ui_resources_;
 
   CompositorFrameSink* compositor_frame_sink_;
 
@@ skipping 119 matching lines @@
   // it's lost instead of having this bool.
   bool has_valid_compositor_frame_sink_;
 
   std::unique_ptr<Viewport> viewport_;
 
   std::unique_ptr<LayerTreeMutator> mutator_;
 
   std::unique_ptr<PendingTreeDurationHistogramTimer>
       pending_tree_duration_timer_;
 
+  ScrollStateForFling cached_scroll_state_for_fling_;
+
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_IMPL_H_