Scrollbar fade animation broken on Android regression resolved.

cc/trees/layer_tree_host_impl.cc

 // 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.
 
 #include "cc/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 138 matching lines @@
   bool scroll_on_main_thread = (scroll_thread == MAIN_THREAD);
   if (IsWheelBasedScroll(type)) {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.CompositorWheelScrollUpdateThread",
                           scroll_on_main_thread);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.CompositorTouchScrollUpdateThread",
                           scroll_on_main_thread);
   }
 }
 
+// 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 its
+// coresponding scroll event.

[tdresser, 2016/10/19 15:28:04]

corresponding

[sahel, 2016/10/25 15:34:14]

Done.

+class ScrollingVariablesState {
+ public:
+  ScrollingVariablesState() {
+    ScrollingVariablesState(false, false, gfx::Vector2dF());
+  }
+  ScrollingVariablesState(bool did_lock_scrolling_layer,
+                          bool scroll_affects_scroll_handler,
+                          gfx::Vector2dF accumulated_root_overscroll)
+      : did_lock_scrolling_layer_(did_lock_scrolling_layer),
+        scroll_affects_scroll_handler_(scroll_affects_scroll_handler),
+        accumulated_root_overscroll_(accumulated_root_overscroll) {}
+
+  bool didLockScrollingLayer() { return did_lock_scrolling_layer_; }
+  bool scrollAffectsScrollHandler() { return scroll_affects_scroll_handler_; }
+  gfx::Vector2dF accumulatedRootOverscroll() {
+    return accumulated_root_overscroll_;
+  }
+
+ private:
+  bool did_lock_scrolling_layer_;
+  bool scroll_affects_scroll_handler_;
+  gfx::Vector2dF accumulated_root_overscroll_;
+};
+
+ScrollingVariablesState CashedScrollingVariablesState;

[tdresser, 2016/10/19 15:28:04]

Variable name should be cached_scrolling_variables_state_.

Can we put this on the LTHI?

[bokan, 2016/10/20 15:35:10]

Is there a reason for this variable to be a local global? If not, please just
make it a member of LTHI, it simplifies lifetime/threading issues.

[sahel, 2016/10/25 15:34:14]

Done.

[sahel, 2016/10/25 15:34:14]

Acknowledged.

+
 }  // namespace
 
 DEFINE_SCOPED_UMA_HISTOGRAM_TIMER(PendingTreeDurationHistogramTimer,
                                   "Scheduling.%s.PendingTreeDuration");
 
 LayerTreeHostImpl::FrameData::FrameData()
     : render_surface_layer_list(nullptr),
       has_no_damage(false),
       may_contain_video(false) {}
 
@@ skipping 89 matching lines @@
   active_tree_->property_trees()->is_active = true;
 
   viewport_ = Viewport::Create(this);
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                                      "cc::LayerTreeHostImpl", id_);
 
   top_controls_manager_ =
       TopControlsManager::Create(this, settings.top_controls_show_threshold,
                                  settings.top_controls_hide_threshold);
+  CashedScrollingVariablesState = ScrollingVariablesState(
+      did_lock_scrolling_layer_, scroll_affects_scroll_handler_,
+      accumulated_root_overscroll_);
 }
 
 LayerTreeHostImpl::~LayerTreeHostImpl() {
   DCHECK(task_runner_provider_->IsImplThread());
   TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                                      "cc::LayerTreeHostImpl", id_);
 
   // It is released before shutdown.
   DCHECK(!compositor_frame_sink_);
@@ skipping 2358 matching lines @@
   return ScrollBeginImpl(scroll_state, viewport()->MainScrollLayer(), type);
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
     ScrollState* scroll_state,
     InputHandler::ScrollInputType type) {
   ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
+  LayerImpl* scrolling_layer_impl = nullptr;
+  // On Mac a scroll begin with |inertial_phase| = true happens to handle a
+  // fling. Also, touchpad fling starts are handled by calling ScrollBegin
+  // instead of FlingScrollBegin.
+  if (scroll_state->is_in_inertial_phase()) {
+    scrolling_layer_impl =
+        active_tree_->LayerById(active_tree_->LastScrolledLayerId());
+    RestoreCachedScrollingVariablesState();
+  }
 
-  // On Mac a scroll begin with |inertial_phase| = true happens to handle a
-  // fling.
-  if (scroll_state->is_in_inertial_phase())
-    return FlingScrollBegin();
+  if (!scrolling_layer_impl) {
+    ClearCurrentlyScrollingLayer();
 
-  ClearCurrentlyScrollingLayer();
+    gfx::Point viewport_point(scroll_state->position_x(),
+                              scroll_state->position_y());
 
-  gfx::Point viewport_point(scroll_state->position_x(),
-                            scroll_state->position_y());
+    gfx::PointF device_viewport_point = gfx::ScalePoint(
+        gfx::PointF(viewport_point), active_tree_->device_scale_factor());
+    LayerImpl* layer_impl =
+        active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
 
-  gfx::PointF device_viewport_point = gfx::ScalePoint(
-      gfx::PointF(viewport_point), active_tree_->device_scale_factor());
-  LayerImpl* layer_impl =
-      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
+    if (layer_impl) {
+      LayerImpl* scroll_layer_impl =
+          active_tree_->FindFirstScrollingLayerOrScrollbarLayerThatIsHitByPoint(
+              device_viewport_point);
+      if (scroll_layer_impl &&
+          !HasScrollAncestor(layer_impl, scroll_layer_impl)) {
+        scroll_status.thread = SCROLL_UNKNOWN;
+        scroll_status.main_thread_scrolling_reasons =
+            MainThreadScrollingReason::kFailedHitTest;
+        return scroll_status;
+      }
+    }
 
-  if (layer_impl) {
-    LayerImpl* scroll_layer_impl =
-        active_tree_->FindFirstScrollingLayerOrScrollbarLayerThatIsHitByPoint(
-            device_viewport_point);
-    if (scroll_layer_impl &&
-        !HasScrollAncestor(layer_impl, scroll_layer_impl)) {
-      scroll_status.thread = SCROLL_UNKNOWN;
-      scroll_status.main_thread_scrolling_reasons =
-          MainThreadScrollingReason::kFailedHitTest;
+    bool scroll_on_main_thread = false;
+    scrolling_layer_impl = FindScrollLayerForDeviceViewportPoint(
+        device_viewport_point, type, layer_impl, &scroll_on_main_thread,
+        &scroll_status.main_thread_scrolling_reasons);
+
+    if (scrolling_layer_impl)
+      scroll_affects_scroll_handler_ =
+          scrolling_layer_impl->layer_tree_impl()->have_scroll_event_handlers();
+
+    if (scroll_on_main_thread) {
+      RecordCompositorSlowScrollMetric(type, MAIN_THREAD);
+
+      scroll_status.thread = SCROLL_ON_MAIN_THREAD;
       return scroll_status;
     }
   }
 
-  bool scroll_on_main_thread = false;
-  LayerImpl* scrolling_layer_impl = FindScrollLayerForDeviceViewportPoint(
-      device_viewport_point, type, layer_impl, &scroll_on_main_thread,
-      &scroll_status.main_thread_scrolling_reasons);
-
-  if (scrolling_layer_impl)
-    scroll_affects_scroll_handler_ =
-        scrolling_layer_impl->layer_tree_impl()->have_scroll_event_handlers();
-
-  if (scroll_on_main_thread) {
-    RecordCompositorSlowScrollMetric(type, MAIN_THREAD);
-
-    scroll_status.thread = SCROLL_ON_MAIN_THREAD;
-    return scroll_status;
-  }
-
   return ScrollBeginImpl(scroll_state, scrolling_layer_impl, type);
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimatedBegin(
     const gfx::Point& viewport_point) {
   InputHandler::ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
   ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
@@ skipping 17 matching lines @@
   // ScrollAnimated is used for animated wheel scrolls. We find the first layer
   // that can scroll and set up an animation of its scroll offset. Note that
   // this does not currently go through the scroll customization machinery
   // that ScrollBy uses for non-animated wheel scrolls.
   scroll_status = ScrollBegin(&scroll_state, WHEEL);
   scroll_node = scroll_tree.CurrentlyScrollingNode();
   if (scroll_status.thread == SCROLL_ON_IMPL_THREAD) {
     ScrollStateData scroll_state_end_data;
     scroll_state_end_data.is_ending = true;
     ScrollState scroll_state_end(scroll_state_end_data);
-    // TODO(Sahel): Once the touchpad scroll latching for Non-mac devices is
-    // implemented, the current scrolling layer should not get cleared after
-    // each animation (crbug.com/526463).
     ScrollEnd(&scroll_state_end);
-    ClearCurrentlyScrollingLayer();
   }
   return scroll_status;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::ComputeScrollDelta(
     ScrollNode* scroll_node,
     const gfx::Vector2dF& delta) {
   ScrollTree& scroll_tree = active_tree()->property_trees()->scroll_tree;
   float scale_factor = active_tree()->current_page_scale_factor();
 
@@ skipping 104 matching lines @@
         gfx::Vector2dF scroll_delta =
             ComputeScrollDelta(scroll_node, pending_delta);
         if (ScrollAnimationCreate(scroll_node, scroll_delta, delayed_by))
           return scroll_status;
 
         pending_delta -= scroll_delta;
       }
     }
   }
   scroll_state.set_is_ending(true);
-  // TODO(Sahel): Once the touchpad scroll latching for Non-mac devices is
-  // implemented, the current scrolling layer should not get cleared after
-  // each animation (crbug.com/526463).
   ScrollEnd(&scroll_state);
-  ClearCurrentlyScrollingLayer();
 
   return scroll_status;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::ScrollNodeWithViewportSpaceDelta(
     ScrollNode* scroll_node,
     const gfx::PointF& viewport_point,
     const gfx::Vector2dF& viewport_delta,
     ScrollTree* scroll_tree) {
   // Layers with non-invertible screen space transforms should not have passed
@@ skipping 287 matching lines @@
   client_->SetNeedsCommitOnImplThread();
   // After applying the synchronous input handler's scroll offset, tell it what
   // we ended up with.
   UpdateRootLayerStateForSynchronousInputHandler();
   SetFullViewportDamage();
   SetNeedsRedraw();
 }
 
 void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
   active_tree_->ClearCurrentlyScrollingLayer();
+  // Cached scrolling variables state is restored in a ScrollBegin with
+  // inertial phase (fling) to latch it to its corresponding scroll. When
+  // reseting a variable here, update ScrollingVariablesState struct as well
+  // to maintain the proper caching.
+  CacheScrollingVariablesState();
   did_lock_scrolling_layer_ = false;
   scroll_affects_scroll_handler_ = false;
   accumulated_root_overscroll_ = gfx::Vector2dF();
 }
 
 void LayerTreeHostImpl::ScrollEnd(ScrollState* scroll_state) {
   DCHECK(scroll_state);
   DCHECK(scroll_state->delta_x() == 0 && scroll_state->delta_y() == 0);
 
   DistributeScrollDelta(scroll_state);
   top_controls_manager_->ScrollEnd();
 
-  if (scroll_state->is_in_inertial_phase()) {
-    // Only clear the currently scrolling layer if we know the scroll is done.
-    // A non-inertial scroll end could be followed by an inertial scroll.
-    ClearCurrentlyScrollingLayer();
-  }
+  ClearCurrentlyScrollingLayer();
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
   InputHandler::ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
   if (!CurrentlyScrollingLayer()) {
     scroll_status.thread = SCROLL_IGNORED;
     scroll_status.main_thread_scrolling_reasons =
         MainThreadScrollingReason::kNoScrollingLayer;
@@ skipping 819 matching lines @@
     return;
   LayerImpl* layer = tree->LayerByElementId(element_id);
   if (layer)
     layer->OnIsAnimatingChanged(mask, state);
 }
 
 void LayerTreeHostImpl::ScrollOffsetAnimationFinished() {
   // TODO(majidvp): We should pass in the original starting scroll position here
   ScrollStateData scroll_state_data;
   ScrollState scroll_state(scroll_state_data);
-  // TODO(Sahel): Once the touchpad scroll latching for Non-mac devices is
-  // implemented, the current scrolling layer should not get cleared after
-  // each animation (crbug.com/526463).
   ScrollEnd(&scroll_state);
-  ClearCurrentlyScrollingLayer();
 }
 
 gfx::ScrollOffset LayerTreeHostImpl::GetScrollOffsetForAnimation(
     ElementId element_id) const {
   if (active_tree()) {
     LayerImpl* layer = active_tree()->LayerByElementId(element_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
@@ skipping 47 matching lines @@
   ContextProvider::ScopedContextLock hold(worker_context);
   if (is_visible) {
     worker_context_visibility_ =
         worker_context->CacheController()->ClientBecameVisible();
   } else {
     worker_context->CacheController()->ClientBecameNotVisible(
         std::move(worker_context_visibility_));
   }
 }
 
+void LayerTreeHostImpl::CacheScrollingVariablesState() {
+  CashedScrollingVariablesState = ScrollingVariablesState(
+      did_lock_scrolling_layer_, scroll_affects_scroll_handler_,
+      accumulated_root_overscroll_);
+}
+void LayerTreeHostImpl::RestoreCachedScrollingVariablesState() {
+  did_lock_scrolling_layer_ =
+      CashedScrollingVariablesState.didLockScrollingLayer();
+  scroll_affects_scroll_handler_ =
+      CashedScrollingVariablesState.scrollAffectsScrollHandler();
+  accumulated_root_overscroll_ =
+      CashedScrollingVariablesState.accumulatedRootOverscroll();
+}
+
 }  // namespace cc