Don't fade in overlay scrollbar when user interacting the content under scrollbar.

cc/input/scrollbar_animation_controller.cc

 // 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.
 
 #include "cc/input/scrollbar_animation_controller.h"
 
 #include <algorithm>
 
 #include "base/time/time.h"
 #include "cc/trees/layer_tree_impl.h"
@@ skipping 35 matching lines @@
       fade_duration_(fade_duration),
       need_trigger_scrollbar_fade_in_(false),
       is_animating_(false),
       animation_change_(NONE),
       scroll_element_id_(scroll_element_id),
       currently_scrolling_(false),
       show_in_fast_scroll_(false),
       opacity_(initial_opacity),
       show_scrollbars_on_scroll_gesture_(false),
       need_thinning_animation_(false),
+      is_mouse_down_(false),
       weak_factory_(this) {}
 
 ScrollbarAnimationController::ScrollbarAnimationController(
     ElementId scroll_element_id,
     ScrollbarAnimationControllerClient* client,
     base::TimeDelta fade_delay,
     base::TimeDelta fade_duration,
     base::TimeDelta thinning_duration,
     float initial_opacity)
     : client_(client),
       fade_delay_(fade_delay),
       fade_duration_(fade_duration),
       need_trigger_scrollbar_fade_in_(false),
       is_animating_(false),
       animation_change_(NONE),
       scroll_element_id_(scroll_element_id),
       currently_scrolling_(false),
       show_in_fast_scroll_(false),
       opacity_(initial_opacity),
       show_scrollbars_on_scroll_gesture_(true),
       need_thinning_animation_(true),
+      is_mouse_down_(false),
       weak_factory_(this) {
   vertical_controller_ = SingleScrollbarAnimationControllerThinning::Create(
       scroll_element_id, ScrollbarOrientation::VERTICAL, client,
       thinning_duration);
   horizontal_controller_ = SingleScrollbarAnimationControllerThinning::Create(
       scroll_element_id, ScrollbarOrientation::HORIZONTAL, client,
       thinning_duration);
 }
 
 ScrollbarAnimationController::~ScrollbarAnimationController() {}
 
 ScrollbarSet ScrollbarAnimationController::Scrollbars() const {
   return client_->ScrollbarsFor(scroll_element_id_);
 }
 
 SingleScrollbarAnimationControllerThinning&
 ScrollbarAnimationController::GetScrollbarAnimationController(
     ScrollbarOrientation orientation) const {
   DCHECK(need_thinning_animation_);
   if (orientation == ScrollbarOrientation::VERTICAL)
     return *(vertical_controller_.get());
   else
     return *(horizontal_controller_.get());
 }
 
 void ScrollbarAnimationController::StartAnimation() {
   DCHECK(animation_change_ != NONE);
   delayed_scrollbar_animation_.Cancel();
+  need_trigger_scrollbar_fade_in_ = false;
   is_animating_ = true;
   last_awaken_time_ = base::TimeTicks();
   client_->SetNeedsAnimateForScrollbarAnimation();
 }
 
 void ScrollbarAnimationController::StopAnimation() {
   delayed_scrollbar_animation_.Cancel();
+  need_trigger_scrollbar_fade_in_ = false;
   is_animating_ = false;
   animation_change_ = NONE;
 }
 
 void ScrollbarAnimationController::PostDelayedAnimation(
     AnimationChange animation_change) {
   animation_change_ = animation_change;
   delayed_scrollbar_animation_.Cancel();
   delayed_scrollbar_animation_.Reset(
       base::Bind(&ScrollbarAnimationController::StartAnimation,
@@ skipping 95 matching lines @@
 void ScrollbarAnimationController::WillUpdateScroll() {
   if (show_scrollbars_on_scroll_gesture_)
     DidScrollUpdate();
 }
 
 void ScrollbarAnimationController::DidRequestShowFromMainThread() {
   DidScrollUpdate();
 }
 
 void ScrollbarAnimationController::DidMouseDown() {
-  if (!need_thinning_animation_ || ScrollbarsHidden())
+  if (!need_thinning_animation_)
     return;
 
+  is_mouse_down_ = true;
+
+  if (ScrollbarsHidden()) {
+    if (need_trigger_scrollbar_fade_in_) {
+      delayed_scrollbar_animation_.Cancel();
+      need_trigger_scrollbar_fade_in_ = false;
+    }
+    return;
+  }
+
   vertical_controller_->DidMouseDown();
   horizontal_controller_->DidMouseDown();
 }
 
 void ScrollbarAnimationController::DidMouseUp() {
-  if (!need_thinning_animation_ || !Captured())
+  if (!need_thinning_animation_)
     return;
 
+  is_mouse_down_ = false;
+
+  if (!Captured()) {
+    if (MouseIsNearAnyScrollbar() && ScrollbarsHidden()) {
+      PostDelayedAnimation(FADE_IN);
+      need_trigger_scrollbar_fade_in_ = true;
+    }
+    return;
+  }
+
   vertical_controller_->DidMouseUp();
   horizontal_controller_->DidMouseUp();
 
-  if (!MouseIsNearAnyScrollbar())
+  if (!MouseIsNearAnyScrollbar() && !ScrollbarsHidden())
     PostDelayedAnimation(FADE_OUT);
 }
 
 void ScrollbarAnimationController::DidMouseLeave() {
   if (!need_thinning_animation_)
     return;
 
   vertical_controller_->DidMouseLeave();
   horizontal_controller_->DidMouseLeave();
 
   delayed_scrollbar_animation_.Cancel();
   need_trigger_scrollbar_fade_in_ = false;
 
   if (ScrollbarsHidden() || Captured())
     return;
 
   PostDelayedAnimation(FADE_OUT);
 }
 
 void ScrollbarAnimationController::DidMouseMove(
     const gfx::PointF& device_viewport_point) {
   if (!need_thinning_animation_)
     return;
 
   bool need_trigger_scrollbar_fade_in_before = need_trigger_scrollbar_fade_in_;
 
   vertical_controller_->DidMouseMove(device_viewport_point);
   horizontal_controller_->DidMouseMove(device_viewport_point);
 
-  need_trigger_scrollbar_fade_in_ = MouseIsNearAnyScrollbar();
-
-  if (Captured())
+  if (Captured()) {
+    DCHECK(!ScrollbarsHidden());
     return;
+  }
 
   if (ScrollbarsHidden()) {
+    // Do not fade in scrollbar when user interacting with the content below
+    // scrollbar.
+    if (is_mouse_down_)
+      return;
+    need_trigger_scrollbar_fade_in_ = MouseIsNearAnyScrollbar();
     if (need_trigger_scrollbar_fade_in_before !=
         need_trigger_scrollbar_fade_in_) {
       if (need_trigger_scrollbar_fade_in_) {
         PostDelayedAnimation(FADE_IN);
       } else {
         delayed_scrollbar_animation_.Cancel();
       }
     }
   } else {
     if (MouseIsNearAnyScrollbar()) {
@@ skipping 60 matching lines @@
   if (opacity_ != opacity)
     client_->SetNeedsRedrawForScrollbarAnimation();
 
   opacity_ = opacity;
 
   if (previouslyVisible != currentlyVisible)
     client_->DidChangeScrollbarVisibility();
 }
 
 }  // namespace cc