currentlyscrollinglayer cleared in scrollAnimatedBegin.

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 2770 matching lines @@
     } else {
       scroll_status.thread = SCROLL_IGNORED;
       scroll_status.main_thread_scrolling_reasons =
           MainThreadScrollingReason::kNotScrollable;
     }
     return scroll_status;
   }
   ScrollStateData scroll_state_data;
   scroll_state_data.position_x = viewport_point.x();
   scroll_state_data.position_y = viewport_point.y();
-  scroll_state_data.is_in_inertial_phase = true;
+  scroll_state_data.is_in_inertial_phase = false;

[ericrk, 2016/08/31 18:29:42]

nit: This is already the default value of is_in_inertial_phase, no need to set
it. There are lots of other fields on ScrollStateData which we don't explicitly
set if left at default, so not setting this seems consistent.

Also update the other occurrence in ScrollAnimated

[sahel, 2016/08/31 19:16:46]

Done.

   ScrollState scroll_state(scroll_state_data);
 
   // 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 103 matching lines @@
             ComputeScrollDelta(scroll_node, pending_delta);
         if (ScrollAnimationCreate(scroll_node, scroll_delta))
           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
-  // impelemented, the current scrolling layer should not get cleared after
+  // 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,
@@ skipping 1220 matching lines @@
         break;
     }
   }
 }
 
 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
-  // impelemented, the current scrolling layer should not get cleared after
+  // 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();
   }
 
   return gfx::ScrollOffset();
 }
 
 bool LayerTreeHostImpl::SupportsImplScrolling() const {
   // Supported in threaded mode.
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc