Call SAC::DidScrollUpdate only for compositor-triggered scrolls.

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 331 matching lines @@
 
   UpdateSyncTreeAfterCommitOrImplSideInvalidation();
   micro_benchmark_controller_.DidCompleteCommit();
 }
 
 void LayerTreeHostImpl::UpdateSyncTreeAfterCommitOrImplSideInvalidation() {
   sync_tree()->InvalidateRegionForImages(
       tile_manager_.TakeImagesToInvalidateOnSyncTree());
 
   if (CommitToActiveTree()) {
+    active_tree_->ShowScrollbars();

[bokan, 2017/04/25 22:56:48]

I was a little confused until I checked the ShowScrollbars implementation. Could
we rename it to something like ShowScrollbarsIfRequestedFromMain? Something to
clarify that it's not just forcing display of scrollbars.

[skobes, 2017/04/27 00:46:31]

Renamed to HandleScrollbarShowRequestsFromMain.

+
     // We have to activate animations here or "IsActive()" is true on the layers
     // but the animations aren't activated yet so they get ignored by
     // UpdateDrawProperties.
     ActivateAnimations();
   }
 
   // Start animations before UpdateDrawProperties and PrepareTiles, as they can
   // change the results. When doing commit to the active tree, this must happen
   // after ActivateAnimations() in order for this ticking to be propogated to
   // layers on the active tree.
@@ skipping 2911 matching lines @@
       browser_controls_offset_manager_->ControlsTopOffset();
 
   scroll_state->set_delta_consumed_for_scroll_sequence(
       did_lock_scrolling_layer_);
   scroll_state->set_is_direct_manipulation(!wheel_scrolling_);
   scroll_state->set_current_native_scrolling_node(
       active_tree()->property_trees()->scroll_tree.CurrentlyScrollingNode());
 
   DistributeScrollDelta(scroll_state);
 
-  active_tree_->SetCurrentlyScrollingNode(
-      scroll_state->current_native_scrolling_node());
+  ScrollNode* current_scrolling_node =
+      scroll_state->current_native_scrolling_node();
+  active_tree_->SetCurrentlyScrollingNode(current_scrolling_node);
   did_lock_scrolling_layer_ =
       scroll_state->delta_consumed_for_scroll_sequence();
 
   bool did_scroll_x = scroll_state->caused_scroll_x();
   bool did_scroll_y = scroll_state->caused_scroll_y();
   bool did_scroll_content = did_scroll_x || did_scroll_y;
   if (did_scroll_content) {
+    ShowScrollbarsForImplScroll(current_scrolling_node->element_id);
+
     // If we are scrolling with an active scroll handler, forward latency
     // tracking information to the main thread so the delay introduced by the
     // handler is accounted for.
     if (scroll_affects_scroll_handler())
       NotifySwapPromiseMonitorsOfForwardingToMainThread();
     client_->SetNeedsCommitOnImplThread();
     SetNeedsRedraw();
     client_->RenewTreePriority();
   }
 
@@ skipping 40 matching lines @@
 void LayerTreeHostImpl::RequestUpdateForSynchronousInputHandler() {
   UpdateRootLayerStateForSynchronousInputHandler();
 }
 
 void LayerTreeHostImpl::SetSynchronousInputHandlerRootScrollOffset(
     const gfx::ScrollOffset& root_offset) {
   bool changed = active_tree_->DistributeRootScrollOffset(root_offset);
   if (!changed)
     return;
 
+  ShowScrollbarsForImplScroll(OuterViewportScrollLayer()->element_id());
   client_->SetNeedsCommitOnImplThread();
   // After applying the synchronous input handler's scroll offset, tell it what
   // we ended up with.
   UpdateRootLayerStateForSynchronousInputHandler();
   SetFullViewportDamage();
   SetNeedsRedraw();
 }
 
 void LayerTreeHostImpl::ClearCurrentlyScrollingNode() {
   active_tree_->ClearCurrentlyScrollingNode();
@@ skipping 781 matching lines @@
       recycle_tree()->SetTransformMutated(element_id, transform);
   }
 }
 
 void LayerTreeHostImpl::SetElementScrollOffsetMutated(
     ElementId element_id,
     ElementListType list_type,
     const gfx::ScrollOffset& scroll_offset) {
   if (list_type == ElementListType::ACTIVE) {
     SetTreeLayerScrollOffsetMutated(element_id, active_tree(), scroll_offset);
+    ShowScrollbarsForImplScroll(element_id);
   } else {
     SetTreeLayerScrollOffsetMutated(element_id, pending_tree(), scroll_offset);
     SetTreeLayerScrollOffsetMutated(element_id, recycle_tree(), scroll_offset);
   }
 }
 
 void LayerTreeHostImpl::ElementIsAnimatingChanged(
     ElementId element_id,
     ElementListType list_type,
     const PropertyAnimationState& mask,
@@ skipping 132 matching lines @@
   }
 }
 
 void LayerTreeHostImpl::UpdateScrollSourceInfo(bool is_wheel_scroll) {
   if (is_wheel_scroll)
     has_scrolled_by_wheel_ = true;
   else
     has_scrolled_by_touch_ = true;
 }
 
+void LayerTreeHostImpl::ShowScrollbarsForImplScroll(ElementId element_id) {
+  if (!element_id)
+    return;
+  if (ScrollbarAnimationController* animation_controller =
+          ScrollbarAnimationControllerForElementId(element_id))
+    animation_controller->DidScrollUpdate();
+}
+
 }  // namespace cc