BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

21 files changed, 380 insertions, 320 deletions

diff --git a/chromium/cc/input/browser_controls_offset_manager.cc b/chromium/cc/input/browser_controls_offset_manager.cc
index ea4c6e27993..5ebc925c1e6 100644
--- a/chromium/cc/input/browser_controls_offset_manager.cc
+++ b/chromium/cc/input/browser_controls_offset_manager.cc
@@ -207,17 +207,20 @@ void BrowserControlsOffsetManager::OnBrowserControlsParamsChanged(
     return;
   }
 
+  // We continue to update both top and bottom controls even if one has a height
+  // of 0 so that animations work properly. So here, we should preserve the
+  // ratios even if the controls height is 0.
   float old_top_height = old_browser_controls_params_.top_controls_height;
   float new_top_ratio =
       TopControlsHeight()
           ? TopControlsShownRatio() * old_top_height / TopControlsHeight()
-          : 0.f;
+          : TopControlsShownRatio();
 
   float old_bottom_height = old_browser_controls_params_.bottom_controls_height;
   float new_bottom_ratio = BottomControlsHeight()
                                ? BottomControlsShownRatio() *
                                      old_bottom_height / BottomControlsHeight()
-                               : 0.f;
+                               : BottomControlsShownRatio();
 
   if (!animate_changes) {
     // If the min-heights changed when the controls were at the min-height, the
@@ -268,8 +271,13 @@ void BrowserControlsOffsetManager::OnBrowserControlsParamsChanged(
   bool bottom_controls_need_animation = animate_changes;
 
   float top_target_ratio;
-  // If the top controls height changed when they were fully shown.
-  if (TopControlsShownRatio() == 1.f && TopControlsHeight() != old_top_height) {
+  // We can't animate if we don't have top controls.
+  if (!TopControlsHeight()) {
+    top_controls_need_animation = false;
+
+    // If the top controls height changed when they were fully shown.
+  } else if (TopControlsShownRatio() == 1.f &&
+             TopControlsHeight() != old_top_height) {
     top_target_ratio = 1.f;  // i.e. new_height / new_height
 
     // If the top controls min-height changed when they were at the minimum
@@ -284,9 +292,13 @@ void BrowserControlsOffsetManager::OnBrowserControlsParamsChanged(
   }
 
   float bottom_target_ratio;
-  // If the bottom controls height changed when they were fully shown.
-  if (BottomControlsShownRatio() == 1.f &&
-      BottomControlsHeight() != old_bottom_height) {
+  // We can't animate if we don't have bottom controls.
+  if (!BottomControlsHeight()) {
+    bottom_controls_need_animation = false;
+
+    // If the bottom controls height changed when they were fully shown.
+  } else if (BottomControlsShownRatio() == 1.f &&
+             BottomControlsHeight() != old_bottom_height) {
     bottom_target_ratio = 1.f;  // i.e. new_height / new_height
 
     // If the bottom controls min-height changed when they were at the minimum
diff --git a/chromium/cc/input/browser_controls_offset_manager_unittest.cc b/chromium/cc/input/browser_controls_offset_manager_unittest.cc
index 8c443fd0bee..507ca1f3a5a 100644
--- a/chromium/cc/input/browser_controls_offset_manager_unittest.cc
+++ b/chromium/cc/input/browser_controls_offset_manager_unittest.cc
@@ -1087,5 +1087,61 @@ TEST(BrowserControlsOffsetManagerTest, ScrollWithMinHeightSetForBothControls) {
   manager->ScrollEnd();
 }
 
+TEST(BrowserControlsOffsetManagerTest, ChangingBottomHeightFromZeroAnimates) {
+  MockBrowserControlsOffsetManagerClient client(100, 0.5f, 0.5f);
+  client.SetBrowserControlsParams({100, 30, 0, 0, false, false});
+  BrowserControlsOffsetManager* manager = client.manager();
+  EXPECT_FLOAT_EQ(1.f, client.CurrentTopControlsShownRatio());
+  EXPECT_FLOAT_EQ(1.f, client.CurrentBottomControlsShownRatio());
+
+  // Set the bottom controls height to 100 with animation.
+  client.SetBrowserControlsParams({100, 30, 100, 0, true, false});
+  EXPECT_TRUE(manager->HasAnimation());
+  // The bottom controls should be hidden in the beginning.
+  EXPECT_FLOAT_EQ(0.f, manager->ContentBottomOffset());
+  EXPECT_FLOAT_EQ(0.f, client.CurrentBottomControlsShownRatio());
+
+  base::TimeTicks time = base::TimeTicks::Now();
+
+  // First animate will establish the animaion.
+  float previous_ratio = manager->BottomControlsShownRatio();
+  manager->Animate(time);
+  EXPECT_EQ(manager->BottomControlsShownRatio(), previous_ratio);
+
+  while (manager->HasAnimation()) {
+    previous_ratio = manager->BottomControlsShownRatio();
+    time = base::TimeDelta::FromMicroseconds(100) + time;
+    manager->Animate(time);
+    EXPECT_GT(manager->BottomControlsShownRatio(), previous_ratio);
+  }
+
+  // Now the bottom controls should be fully shown.
+  EXPECT_FLOAT_EQ(100.f, manager->ContentBottomOffset());
+  EXPECT_FLOAT_EQ(1.f, client.CurrentBottomControlsShownRatio());
+}
+
+TEST(BrowserControlsOffsetManagerTest,
+     ChangingControlsHeightToZeroWithAnimationIsNoop) {
+  MockBrowserControlsOffsetManagerClient client(100, 0.5f, 0.5f);
+  client.SetBrowserControlsParams({100, 20, 80, 10, false, false});
+  BrowserControlsOffsetManager* manager = client.manager();
+  EXPECT_FLOAT_EQ(1.f, client.CurrentTopControlsShownRatio());
+  EXPECT_FLOAT_EQ(1.f, client.CurrentBottomControlsShownRatio());
+
+  // Set the bottom controls height to 0 with animation.
+  client.SetBrowserControlsParams({100, 20, 0, 0, true, false});
+
+  // There shouldn't be an animation because we can't animate controls with 0
+  // height.
+  EXPECT_FALSE(manager->HasAnimation());
+  // Also, the bottom controls ratio should stay the same.
+  EXPECT_FLOAT_EQ(1.f, client.CurrentBottomControlsShownRatio());
+
+  // Increase the top controls height with animation.
+  client.SetBrowserControlsParams({120, 20, 0, 0, true, false});
+  // This shouldn't override the bottom controls shown ratio.
+  EXPECT_FLOAT_EQ(1.f, client.CurrentBottomControlsShownRatio());
+}
+
 }  // namespace
 }  // namespace cc
diff --git a/chromium/cc/input/input_handler.cc b/chromium/cc/input/input_handler.cc
deleted file mode 100644
index 55ca46ef2c0..00000000000
--- a/chromium/cc/input/input_handler.cc
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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/input_handler.h"
-
-namespace cc {
-
-InputHandlerScrollResult::InputHandlerScrollResult()
-    : did_scroll(false), did_overscroll_root(false) {
-}
-
-InputHandlerPointerResult::InputHandlerPointerResult()
-    : type(kUnhandled),
-      scroll_units(ui::ScrollGranularity::kScrollByPrecisePixel) {}
-
-}  // namespace cc
diff --git a/chromium/cc/input/input_handler.h b/chromium/cc/input/input_handler.h
index eaaa9afde45..43309848b23 100644
--- a/chromium/cc/input/input_handler.h
+++ b/chromium/cc/input/input_handler.h
@@ -50,13 +50,14 @@ enum class ScrollBeginThreadState {
 };
 
 struct CC_EXPORT InputHandlerPointerResult {
-  InputHandlerPointerResult();
+  InputHandlerPointerResult() = default;
   // Tells what type of processing occurred in the input handler as a result of
   // the pointer event.
-  PointerResultType type;
+  PointerResultType type = kUnhandled;
 
   // Tells what scroll_units should be used.
-  ui::ScrollGranularity scroll_units;
+  ui::ScrollGranularity scroll_units =
+      ui::ScrollGranularity::kScrollByPrecisePixel;
 
   // If the input handler processed the event as a scrollbar scroll, it will
   // return a gfx::ScrollOffset that produces the necessary scroll. However,
@@ -73,11 +74,11 @@ struct CC_EXPORT InputHandlerPointerResult {
 };
 
 struct CC_EXPORT InputHandlerScrollResult {
-  InputHandlerScrollResult();
+  InputHandlerScrollResult() = default;
   // Did any layer scroll as a result this ScrollUpdate call?
-  bool did_scroll;
+  bool did_scroll = false;
   // Was any of the scroll delta argument to this ScrollUpdate call not used?
-  bool did_overscroll_root;
+  bool did_overscroll_root = false;
   // The total overscroll that has been accumulated by all ScrollUpdate calls
   // that have had overscroll since the last ScrollBegin call. This resets upon
   // a ScrollUpdate with no overscroll.
@@ -139,17 +140,25 @@ class CC_EXPORT InputHandler {
   InputHandler& operator=(const InputHandler&) = delete;
 
   struct ScrollStatus {
-    ScrollStatus()
-        : thread(SCROLL_ON_IMPL_THREAD),
-          main_thread_scrolling_reasons(
-              MainThreadScrollingReason::kNotScrollingOnMain),
-          bubble(false) {}
+    ScrollStatus() = default;
     ScrollStatus(ScrollThread thread, uint32_t main_thread_scrolling_reasons)
         : thread(thread),
           main_thread_scrolling_reasons(main_thread_scrolling_reasons) {}
-    ScrollThread thread;
-    uint32_t main_thread_scrolling_reasons;
-    bool bubble;
+    ScrollStatus(ScrollThread thread,
+                 uint32_t main_thread_scrolling_reasons,
+                 bool needs_main_thread_hit_test)
+        : thread(thread),
+          main_thread_scrolling_reasons(main_thread_scrolling_reasons),
+          needs_main_thread_hit_test(needs_main_thread_hit_test) {}
+    ScrollThread thread = SCROLL_ON_IMPL_THREAD;
+    uint32_t main_thread_scrolling_reasons =
+        MainThreadScrollingReason::kNotScrollingOnMain;
+    bool bubble = false;
+
+    // Used only in scroll unification. Tells the caller that the input handler
+    // detected a case where it cannot reliably target a scroll node and needs
+    // the main thread to perform a hit test.
+    bool needs_main_thread_hit_test = false;
   };
 
   enum class TouchStartOrMoveEventListenerType {
@@ -256,7 +265,7 @@ class CC_EXPORT InputHandler {
   // suppress scrolling by consuming touch events that started at
   // |viewport_point|, and whether |viewport_point| is on the currently
   // scrolling layer.
-  // |out_touch_action| is assigned the whitelisted touch action for the
+  // |out_touch_action| is assigned the allowed touch action for the
   // |viewport_point|. In the case there are no touch handlers or touch action
   // regions, |out_touch_action| is assigned TouchAction::kAuto since the
   // default touch action is auto.
diff --git a/chromium/cc/input/main_thread_scrolling_reason.cc b/chromium/cc/input/main_thread_scrolling_reason.cc
index b84c31dd04c..a116970e49b 100644
--- a/chromium/cc/input/main_thread_scrolling_reason.cc
+++ b/chromium/cc/input/main_thread_scrolling_reason.cc
@@ -44,14 +44,10 @@ void MainThreadScrollingReason::AddToTracedValue(
     traced_value.AppendString("Handling scroll from main thread");
   if (reasons & kHasTransformAndLCDText)
     traced_value.AppendString("Has transform and LCD text");
-  if (reasons & kBackgroundNotOpaqueInRectAndLCDText)
-    traced_value.AppendString("Background is not opaque in rect and LCD text");
-  if (reasons & kCantPaintScrollingBackground)
-    traced_value.AppendString("Can't paint scrolling background");
-  if (reasons & kHasClipRelatedProperty)
-    traced_value.AppendString("Has clip related property");
-  if (reasons & kIsNotStackingContextAndLCDText)
-    traced_value.AppendString("Is not stacking context and LCD text");
+  if (reasons & kNotOpaqueForTextAndLCDText)
+    traced_value.AppendString("Not opaque for text and LCD text");
+  if (reasons & kCantPaintScrollingBackgroundAndLCDText)
+    traced_value.AppendString("Can't paint scrolling background and LCD text");
 
   // Transient scrolling reasons.
   if (reasons & kNonFastScrollableRegion)
diff --git a/chromium/cc/input/main_thread_scrolling_reason.h b/chromium/cc/input/main_thread_scrolling_reason.h
index cd129cf69fc..8354bbb401d 100644
--- a/chromium/cc/input/main_thread_scrolling_reason.h
+++ b/chromium/cc/input/main_thread_scrolling_reason.h
@@ -44,10 +44,8 @@ struct CC_EXPORT MainThreadScrollingReason {
     // screen position; transparency and transforms break this.
     kNonCompositedReasonsFirst = 17,
     kHasTransformAndLCDText = 1 << 17,
-    kBackgroundNotOpaqueInRectAndLCDText = 1 << 18,
-    kCantPaintScrollingBackground = 1 << 19,
-    kHasClipRelatedProperty = 1 << 20,
-    kIsNotStackingContextAndLCDText = 1 << 22,
+    kNotOpaqueForTextAndLCDText = 1 << 18,
+    kCantPaintScrollingBackgroundAndLCDText = 1 << 19,
     kNonCompositedReasonsLast = 22,
 
     // Transient scrolling reasons. These are computed for each scroll begin.
@@ -69,9 +67,8 @@ struct CC_EXPORT MainThreadScrollingReason {
   };
 
   static const uint32_t kNonCompositedReasons =
-      kHasTransformAndLCDText | kBackgroundNotOpaqueInRectAndLCDText |
-      kCantPaintScrollingBackground | kHasClipRelatedProperty |
-      kIsNotStackingContextAndLCDText;
+      kHasTransformAndLCDText | kNotOpaqueForTextAndLCDText |
+      kCantPaintScrollingBackgroundAndLCDText;
 
   // Returns true if the given MainThreadScrollingReason can be set by the main
   // thread.
diff --git a/chromium/cc/input/main_thread_scrolling_reason_unittest.cc b/chromium/cc/input/main_thread_scrolling_reason_unittest.cc
index 7cf3f40d164..4f8b75516af 100644
--- a/chromium/cc/input/main_thread_scrolling_reason_unittest.cc
+++ b/chromium/cc/input/main_thread_scrolling_reason_unittest.cc
@@ -20,10 +20,8 @@ TEST_F(MainThreadScrollingReasonTest, AsText) {
       "Frame overlay, "
       "Handling scroll from main thread, "
       "Has transform and LCD text, "
-      "Background is not opaque in rect and LCD text, "
-      "Can't paint scrolling background, "
-      "Has clip related property, "
-      "Is not stacking context and LCD text, "
+      "Not opaque for text and LCD text, "
+      "Can't paint scrolling background and LCD text, "
       "Non fast scrollable region, "
       "Failed hit test, "
       "No scrolling layer, "
diff --git a/chromium/cc/input/scroll_elasticity_helper.cc b/chromium/cc/input/scroll_elasticity_helper.cc
index 739daaa72a3..451bfcd81ba 100644
--- a/chromium/cc/input/scroll_elasticity_helper.cc
+++ b/chromium/cc/input/scroll_elasticity_helper.cc
@@ -18,6 +18,7 @@ class ScrollElasticityHelperImpl : public ScrollElasticityHelper {
 
   bool IsUserScrollable() const override;
   gfx::Vector2dF StretchAmount() const override;
+  gfx::Size ScrollBounds() const override;
   void SetStretchAmount(const gfx::Vector2dF& stretch_amount) override;
   gfx::ScrollOffset ScrollOffset() const override;
   gfx::ScrollOffset MaxScrollOffset() const override;
@@ -46,6 +47,12 @@ gfx::Vector2dF ScrollElasticityHelperImpl::StretchAmount() const {
   return host_impl_->active_tree()->elastic_overscroll()->Current(true);
 }
 
+gfx::Size ScrollElasticityHelperImpl::ScrollBounds() const {
+  return host_impl_->OuterViewportScrollNode()
+             ? host_impl_->OuterViewportScrollNode()->container_bounds
+             : gfx::Size();
+}
+
 void ScrollElasticityHelperImpl::SetStretchAmount(
     const gfx::Vector2dF& stretch_amount) {
   if (stretch_amount == StretchAmount())
diff --git a/chromium/cc/input/scroll_elasticity_helper.h b/chromium/cc/input/scroll_elasticity_helper.h
index 81281310ecb..4ae282fe51b 100644
--- a/chromium/cc/input/scroll_elasticity_helper.h
+++ b/chromium/cc/input/scroll_elasticity_helper.h
@@ -8,6 +8,7 @@
 #include "base/time/time.h"
 #include "cc/cc_export.h"
 #include "ui/gfx/geometry/scroll_offset.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/vector2d_f.h"
 
 namespace cc {
@@ -54,6 +55,9 @@ class CC_EXPORT ScrollElasticityHelper {
 
   virtual bool IsUserScrollable() const = 0;
 
+  // The bounds of the root scroller.
+  virtual gfx::Size ScrollBounds() const = 0;
+
   // The amount that the view is stretched past the normal allowable bounds.
   virtual gfx::Vector2dF StretchAmount() const = 0;
   virtual void SetStretchAmount(const gfx::Vector2dF& stretch_amount) = 0;
diff --git a/chromium/cc/input/scroll_state.h b/chromium/cc/input/scroll_state.h
index a73b9b117c4..8ac3850ca51 100644
--- a/chromium/cc/input/scroll_state.h
+++ b/chromium/cc/input/scroll_state.h
@@ -86,6 +86,14 @@ class CC_EXPORT ScrollState {
   // it's a scroll update
   gfx::ScrollOffset DeltaOrHint() const;
 
+  ElementId target_element_id() const {
+    return data_.current_native_scrolling_element();
+  }
+
+  bool is_main_thread_hit_tested() const {
+    return data_.is_main_thread_hit_tested;
+  }
+
   ScrollStateData* data() { return &data_; }
 
  private:
diff --git a/chromium/cc/input/scroll_state_data.cc b/chromium/cc/input/scroll_state_data.cc
index 4c472790f15..f18676f4b85 100644
--- a/chromium/cc/input/scroll_state_data.cc
+++ b/chromium/cc/input/scroll_state_data.cc
@@ -25,7 +25,8 @@ ScrollStateData::ScrollStateData()
       delta_granularity(ui::ScrollGranularity::kScrollByPrecisePixel),
       caused_scroll_x(false),
       caused_scroll_y(false),
-      is_scroll_chain_cut(false) {}
+      is_scroll_chain_cut(false),
+      is_main_thread_hit_tested(false) {}
 
 ScrollStateData::ScrollStateData(const ScrollStateData& other) = default;
 
diff --git a/chromium/cc/input/scroll_state_data.h b/chromium/cc/input/scroll_state_data.h
index 297517031ae..a3a2755c61b 100644
--- a/chromium/cc/input/scroll_state_data.h
+++ b/chromium/cc/input/scroll_state_data.h
@@ -70,12 +70,18 @@ class CC_EXPORT ScrollStateData {
   ElementId current_native_scrolling_element() const;
   void set_current_native_scrolling_element(ElementId element_id);
 
+  // Used in scroll unification to specify that a scroll state has been hit
+  // tested on the main thread. If this is true, the hit test result will be
+  // placed in the current_native_scrolling_element_.
+  bool is_main_thread_hit_tested;
+
  private:
   // The id of the last native element to respond to a scroll, or 0 if none
   // exists.
   // TODO(bokan): In the compositor, this is now only used as an override to
-  // scroller targeting, i.e. we'll latch scrolling to the specified
-  // element_id. It will be renamed when the main thread is also converted.
+  // scroller targeting. I.e. we'll latch scrolling to the specified
+  // element_id. It will be renamed to a better name (target_element_id?) when
+  // the main thread is also converted.
   ElementId current_native_scrolling_element_;
 };
 
diff --git a/chromium/cc/input/scroll_utils.cc b/chromium/cc/input/scroll_utils.cc
new file mode 100644
index 00000000000..e9c036e3896
--- /dev/null
+++ b/chromium/cc/input/scroll_utils.cc
@@ -0,0 +1,45 @@
+// Copyright 2020 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/scroll_utils.h"
+
+#include "base/numerics/ranges.h"
+#include "ui/gfx/geometry/size_f.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace cc {
+
+// static
+gfx::Vector2dF ScrollUtils::ResolveScrollPercentageToPixels(
+    const gfx::Vector2dF& delta,
+    const gfx::SizeF& scroller,
+    const gfx::SizeF& viewport) {
+  // Work with unsigned values and keep sign information in sign_x / sign_y.
+  float sign_x = std::signbit(delta.x()) ? -1 : 1;
+  float sign_y = std::signbit(delta.y()) ? -1 : 1;
+  float delta_x = std::abs(delta.x());
+  float delta_y = std::abs(delta.y());
+
+  // Resolved deltas in percent based scrolling are clamped at min by 16 pixels.
+  float min = kMinPixelDeltaForPercentBasedScroll;
+
+  // Resolve and clamp horizontal scroll
+  if (delta_x > 0) {
+    delta_x = delta_x * std::min(scroller.width(), viewport.width());
+    if (delta_x < min)
+      delta_x = min;
+  }
+
+  // Resolve and clamps vertical scroll.
+  if (delta_y > 0) {
+    delta_y = delta_y * std::min(scroller.height(), viewport.height());
+    if (delta_y < min)
+      delta_y = min;
+  }
+
+  return gfx::Vector2dF(std::copysign(delta_x, sign_x),
+                        std::copysign(delta_y, sign_y));
+}
+
+}  // namespace cc
diff --git a/chromium/cc/input/scroll_utils.h b/chromium/cc/input/scroll_utils.h
new file mode 100644
index 00000000000..34fb3be7773
--- /dev/null
+++ b/chromium/cc/input/scroll_utils.h
@@ -0,0 +1,43 @@
+// Copyright 2020 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_INPUT_SCROLL_UTILS_H_
+#define CC_INPUT_SCROLL_UTILS_H_
+
+#include "cc/cc_export.h"
+
+namespace gfx {
+class Vector2dF;
+class SizeF;
+}  // namespace gfx
+
+namespace cc {
+
+static constexpr int kPixelsPerLineStep = 40;
+static constexpr float kMinFractionToStepWhenPaging = 0.875f;
+
+// Each directional scroll for percentage-based units should scroll 1/8th of
+// the scrollable area.
+static constexpr float kPercentDeltaForDirectionalScroll = 0.125f;
+
+// Scroll deltas are lower-bounded by 16 physical pixels in percent-based
+// scrolls.
+static constexpr float kMinPixelDeltaForPercentBasedScroll = 16;
+
+// Class for scroll helper methods in cc and blink.
+class CC_EXPORT ScrollUtils {
+ public:
+  // Transforms a |scroll_delta| in percent units to pixel units based in its
+  // |scroller_size|. Clamps it by 16 pixels to avoid too small deltas for tiny
+  // scrollers and 12.5% of |viewport_size| to avoid too large deltas.
+  // Inputs and output muest be in physical pixels.
+  static gfx::Vector2dF ResolveScrollPercentageToPixels(
+      const gfx::Vector2dF& scroll_delta,
+      const gfx::SizeF& scroller_size,
+      const gfx::SizeF& viewport_size);
+};
+
+}  // namespace cc
+
+#endif  // CC_INPUT_SCROLL_UTILS_H_
diff --git a/chromium/cc/input/scrollbar.h b/chromium/cc/input/scrollbar.h
index af8cef429b1..4fc7a3e57e9 100644
--- a/chromium/cc/input/scrollbar.h
+++ b/chromium/cc/input/scrollbar.h
@@ -11,13 +11,6 @@
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 
-static constexpr int kPixelsPerLineStep = 40;
-static constexpr float kMinFractionToStepWhenPaging = 0.875f;
-
-// Each directional scroll for percentage-based units should scroll 1/8th of
-// the scrollable area.
-static constexpr float kPercentDeltaForDirectionalScroll = 0.125f;
-
 // Autoscrolling (on the main thread) happens by applying a delta every 50ms.
 // Hence, pixels per second for a autoscroll cc animation can be calculated as:
 // autoscroll velocity = delta / 0.05 sec = delta x 20
@@ -58,6 +51,7 @@ class Scrollbar : public base::RefCounted<Scrollbar> {
   virtual bool IsOverlay() const = 0;
   virtual bool HasThumb() const = 0;
   virtual bool SupportsDragSnapBack() const = 0;
+  virtual bool JumpOnTrackClick() const = 0;
 
   // The following rects are all relative to the scrollbar's origin.
   // The location of ThumbRect reflects scroll offset, but cc will ignore it
diff --git a/chromium/cc/input/scrollbar_animation_controller.cc b/chromium/cc/input/scrollbar_animation_controller.cc
index 2435aa156fe..50242fb337c 100644
--- a/chromium/cc/input/scrollbar_animation_controller.cc
+++ b/chromium/cc/input/scrollbar_animation_controller.cc
@@ -51,8 +51,6 @@ ScrollbarAnimationController::ScrollbarAnimationController(
       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),
@@ -73,8 +71,6 @@ ScrollbarAnimationController::ScrollbarAnimationController(
       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),
@@ -182,25 +178,6 @@ void ScrollbarAnimationController::RunAnimationFrame(float progress) {
     StopAnimation();
 }
 
-void ScrollbarAnimationController::DidScrollBegin() {
-  currently_scrolling_ = true;
-}
-
-void ScrollbarAnimationController::DidScrollEnd() {
-  bool has_scrolled = show_in_fast_scroll_;
-  show_in_fast_scroll_ = false;
-
-  currently_scrolling_ = false;
-
-  // We don't fade out scrollbar if they need thinning animation and mouse is
-  // near.
-  if (need_thinning_animation_ && MouseIsNearAnyScrollbar())
-    return;
-
-  if (has_scrolled && !tickmarks_showing_)
-    PostDelayedAnimation(FADE_OUT);
-}
-
 void ScrollbarAnimationController::DidScrollUpdate() {
   UpdateScrollbarState();
 }
@@ -213,19 +190,13 @@ void ScrollbarAnimationController::UpdateScrollbarState() {
 
   Show();
 
-  // As an optimization, we avoid spamming fade delay tasks during active fast
-  // scrolls.  But if we're not within one, we need to post every scroll update.
-  if (!currently_scrolling_) {
-    // We don't fade out scrollbar if they need thinning animation (Aura
-    // Overlay) and mouse is near or tickmarks show.
-    if (need_thinning_animation_) {
-      if (!MouseIsNearAnyScrollbar() && !tickmarks_showing_)
-        PostDelayedAnimation(FADE_OUT);
-    } else {
+  // We don't fade out scrollbar if they need thinning animation (Aura
+  // Overlay) and mouse is near or tickmarks show.
+  if (need_thinning_animation_) {
+    if (!MouseIsNearAnyScrollbar() && !tickmarks_showing_)
       PostDelayedAnimation(FADE_OUT);
-    }
   } else {
-    show_in_fast_scroll_ = true;
+    PostDelayedAnimation(FADE_OUT);
   }
 
   if (need_thinning_animation_) {
diff --git a/chromium/cc/input/scrollbar_animation_controller.h b/chromium/cc/input/scrollbar_animation_controller.h
index 67a9ed5c8fc..1f2c22af131 100644
--- a/chromium/cc/input/scrollbar_animation_controller.h
+++ b/chromium/cc/input/scrollbar_animation_controller.h
@@ -72,9 +72,6 @@ class CC_EXPORT ScrollbarAnimationController {
   // Effect both Android and Aura Overlay Scrollbar.
   void DidScrollUpdate();
 
-  void DidScrollBegin();
-  void DidScrollEnd();
-
   void DidMouseDown();
   void DidMouseUp();
   void DidMouseLeave();
@@ -150,8 +147,6 @@ class CC_EXPORT ScrollbarAnimationController {
   AnimationChange animation_change_;
 
   const ElementId scroll_element_id_;
-  bool currently_scrolling_;
-  bool show_in_fast_scroll_;
 
   base::CancelableOnceClosure delayed_scrollbar_animation_;
 
diff --git a/chromium/cc/input/scrollbar_animation_controller_unittest.cc b/chromium/cc/input/scrollbar_animation_controller_unittest.cc
index f9593321d61..985f45bae4b 100644
--- a/chromium/cc/input/scrollbar_animation_controller_unittest.cc
+++ b/chromium/cc/input/scrollbar_animation_controller_unittest.cc
@@ -163,9 +163,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, AppearOnResize) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
   ExpectScrollbarsOpacity(1);
 
   // Make the Layer non-scrollable, scrollbar disappears.
@@ -199,13 +197,9 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, HideOnResize) {
   scroll_layer_->UpdateScrollable();
   UpdateActiveTreeDrawProperties();
 
-  scrollbar_controller_->DidScrollBegin();
-
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FLOAT_EQ(1, h_scrollbar_layer_->Opacity());
 
-  scrollbar_controller_->DidScrollEnd();
-
   // Shrink along Y axis and expand along X, horizontal scrollbar
   // should disappear.
   clip_layer_->SetBounds(gfx::Size(200, 100));
@@ -214,12 +208,8 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, HideOnResize) {
   scroll_layer_->UpdateScrollable();
   UpdateActiveTreeDrawProperties();
 
-  scrollbar_controller_->DidScrollBegin();
-
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FLOAT_EQ(0.0f, h_scrollbar_layer_->Opacity());
-
-  scrollbar_controller_->DidScrollEnd();
 }
 
 // Scroll content. Confirm the scrollbar appears and fades out.
@@ -232,7 +222,6 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, BasicAppearAndFadeOut) {
   EXPECT_TRUE(scrollbar_controller_->ScrollbarsHidden());
 
   // Scrollbar should appear only on scroll update.
-  scrollbar_controller_->DidScrollBegin();
   ExpectScrollbarsOpacity(0);
   EXPECT_TRUE(scrollbar_controller_->ScrollbarsHidden());
 
@@ -240,7 +229,6 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, BasicAppearAndFadeOut) {
   ExpectScrollbarsOpacity(1);
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
 
-  scrollbar_controller_->DidScrollEnd();
   ExpectScrollbarsOpacity(1);
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
 
@@ -295,9 +283,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
@@ -355,9 +341,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MoveNearAndDontFadeOut) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
@@ -396,9 +380,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MoveOverAndDontFadeOut) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
@@ -438,9 +420,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
@@ -466,9 +446,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
@@ -502,9 +480,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, DontFadeWhileCaptured) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
@@ -540,9 +516,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, FadeAfterReleasedFar) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
@@ -591,9 +565,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, DontFadeAfterReleasedNear) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
@@ -630,9 +602,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // A fade out animation should have been enqueued. Start it.
   EXPECT_EQ(kFadeDelay, client_.delay());
@@ -670,9 +640,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, TestCantCaptureWhenFaded) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   EXPECT_EQ(kFadeDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
@@ -748,7 +716,6 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, ScrollWithMouseNear) {
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
 
   // Now that we've received a scroll, we should be thick without an animation.
@@ -756,7 +723,6 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, ScrollWithMouseNear) {
 
   // An animation for the fade should be either null or cancelled, since
   // mouse is still near the scrollbar.
-  scrollbar_controller_->DidScrollEnd();
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 
@@ -775,29 +741,16 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, ScrollWithMouseNear) {
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 }
 
-// Tests that main thread scroll updates immediatley queue a fade out animation
-// without requiring a ScrollEnd.
+// Tests that main thread scroll updates immediately queue a fade out animation
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        MainThreadScrollQueuesFade) {
   ASSERT_TRUE(client_.start_fade().is_null());
 
-  // A ScrollUpdate without a ScrollBegin indicates a main thread scroll update
-  // so we should schedule a fade out animation without waiting for a ScrollEnd
-  // (which will never come).
+  // A ScrollUpdate indicates a main thread scroll update so we should schedule
+  // a fade out animation since there is no scroll end notification.
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_EQ(kFadeDelay, client_.delay());
-
-  client_.start_fade().Reset();
-
-  // If we got a ScrollBegin, we shouldn't schedule the fade out animation until
-  // we get a corresponding ScrollEnd.
-  scrollbar_controller_->DidScrollBegin();
-  scrollbar_controller_->DidScrollUpdate();
-  EXPECT_TRUE(client_.start_fade().is_null());
-  scrollbar_controller_->DidScrollEnd();
-  EXPECT_FALSE(client_.start_fade().is_null());
-  EXPECT_EQ(kFadeDelay, client_.delay());
 }
 
 // Tests that the fade effect is animated.
@@ -806,9 +759,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, FadeAnimated) {
   time += base::TimeDelta::FromSeconds(1);
 
   // Scroll to make the scrollbars visible.
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // Appearance is instant.
   ExpectScrollbarsOpacity(1);
@@ -838,13 +789,10 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, NotifyChangedVisibility) {
 
   EXPECT_CALL(client_, DidChangeScrollbarVisibility()).Times(1);
   // Scroll to make the scrollbars visible.
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
   Mock::VerifyAndClearExpectations(&client_);
 
-  scrollbar_controller_->DidScrollEnd();
-
   // Play out the fade out animation. We shouldn't notify that the scrollbars
   // are hidden until the animation is completly over. We can (but don't have
   // to) notify during the animation that the scrollbars are still visible.
@@ -886,9 +834,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MouseNearEach) {
   time += base::TimeDelta::FromSeconds(1);
 
   // Scroll to make the scrollbars visible.
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // Near vertical scrollbar.
   scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0));
@@ -979,9 +925,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MouseNearBoth) {
   time += base::TimeDelta::FromSeconds(1);
 
   // Scroll to make the scrollbars visible.
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // Move scrollbar thumb to the end of track.
   v_scrollbar_layer_->SetCurrentPos(100);
@@ -1012,9 +956,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
   time += base::TimeDelta::FromSeconds(1);
 
   // Scroll to make the scrollbars visible.
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // Near vertical scrollbar.
   scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0));
@@ -1076,9 +1018,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MouseLeaveFadeOut) {
   scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0));
 
   // Scroll to make the scrollbars visible.
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   // Should not have delay fadeout animation.
   EXPECT_TRUE(client_.start_fade().is_null() ||
@@ -1323,11 +1263,9 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, TickmakrsShowHide) {
               client_.start_fade().IsCancelled());
 
   // Scroll update with phase, no delay fade animation.
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
-  scrollbar_controller_->DidScrollEnd();
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 
@@ -1430,13 +1368,11 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, HiddenInBegin) {
 TEST_F(ScrollbarAnimationControllerAndroidTest,
        HiddenAfterNonScrollingGesture) {
   scrollbar_layer_->SetOverlayScrollbarLayerOpacityAnimated(0.f);
-  scrollbar_controller_->DidScrollBegin();
 
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(100);
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
-  scrollbar_controller_->DidScrollEnd();
 
   EXPECT_TRUE(start_fade_.is_null());
 
@@ -1473,11 +1409,9 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, HideOnResize) {
   GetScrollNode(scroll_layer_)->container_bounds = gfx::Size(100, 200);
   scroll_layer_->UpdateScrollable();
   UpdateActiveTreeDrawProperties();
-  scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
-  scrollbar_controller_->DidScrollEnd();
 
   // Shrink along Y axis and expand along X, horizontal scrollbar
   // should disappear.
@@ -1485,12 +1419,8 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, HideOnResize) {
   scroll_layer_->UpdateScrollable();
   UpdateActiveTreeDrawProperties();
 
-  scrollbar_controller_->DidScrollBegin();
-
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
-
-  scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(VerticalScrollbarAnimationControllerAndroidTest, HideOnResize) {
@@ -1502,23 +1432,17 @@ TEST_F(VerticalScrollbarAnimationControllerAndroidTest, HideOnResize) {
   GetScrollNode(scroll_layer_)->container_bounds = gfx::Size(100, 200);
   scroll_layer_->UpdateScrollable();
   UpdateActiveTreeDrawProperties();
-  scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
-  scrollbar_controller_->DidScrollEnd();
 
   // Shrink along Y axis and expand along X, vertical scrollbar should appear.
   GetScrollNode(scroll_layer_)->container_bounds = gfx::Size(200, 100);
   scroll_layer_->UpdateScrollable();
   UpdateActiveTreeDrawProperties();
 
-  scrollbar_controller_->DidScrollBegin();
-
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
-
-  scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest, HideOnUserNonScrollableHorz) {
@@ -1527,12 +1451,8 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, HideOnUserNonScrollableHorz) {
   GetScrollNode(scroll_layer_)->user_scrollable_horizontal = false;
   UpdateActiveTreeDrawProperties();
 
-  scrollbar_controller_->DidScrollBegin();
-
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
-
-  scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest, ShowOnUserNonScrollableVert) {
@@ -1541,12 +1461,8 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, ShowOnUserNonScrollableVert) {
   GetScrollNode(scroll_layer_)->user_scrollable_vertical = false;
   UpdateActiveTreeDrawProperties();
 
-  scrollbar_controller_->DidScrollBegin();
-
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
-
-  scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(VerticalScrollbarAnimationControllerAndroidTest,
@@ -1556,12 +1472,8 @@ TEST_F(VerticalScrollbarAnimationControllerAndroidTest,
   GetScrollNode(scroll_layer_)->user_scrollable_vertical = false;
   UpdateActiveTreeDrawProperties();
 
-  scrollbar_controller_->DidScrollBegin();
-
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
-
-  scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(VerticalScrollbarAnimationControllerAndroidTest,
@@ -1571,32 +1483,26 @@ TEST_F(VerticalScrollbarAnimationControllerAndroidTest,
   GetScrollNode(scroll_layer_)->user_scrollable_horizontal = false;
   UpdateActiveTreeDrawProperties();
 
-  scrollbar_controller_->DidScrollBegin();
-
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
-
-  scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest, AwakenByScrollingGesture) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
-  scrollbar_controller_->DidScrollBegin();
   EXPECT_FALSE(did_request_animate_);
 
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FALSE(did_request_animate_);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
 
-  EXPECT_TRUE(start_fade_.is_null());
+  EXPECT_FALSE(start_fade_.is_null());
 
   time += base::TimeDelta::FromSeconds(100);
 
   scrollbar_controller_->Animate(time);
   EXPECT_FALSE(did_request_animate_);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
-  scrollbar_controller_->DidScrollEnd();
   EXPECT_FALSE(did_request_animate_);
   std::move(start_fade_).Run();
   EXPECT_TRUE(did_request_animate_);
@@ -1622,9 +1528,7 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, AwakenByScrollingGesture) {
 
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
-  scrollbar_controller_->DidScrollEnd();
 
   std::move(start_fade_).Run();
   EXPECT_TRUE(did_request_animate_);
@@ -1743,7 +1647,6 @@ TEST_F(ScrollbarAnimationControllerAndroidTest,
   did_request_animate_ = false;
   EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
 
-  scrollbar_controller_->DidScrollBegin();
   EXPECT_FALSE(did_request_animate_);
   EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
 
@@ -1753,7 +1656,6 @@ TEST_F(ScrollbarAnimationControllerAndroidTest,
   did_request_animate_ = false;
   EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity());
 
-  scrollbar_controller_->DidScrollEnd();
   EXPECT_FALSE(did_request_animate_);
   EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity());
 
@@ -1783,7 +1685,6 @@ TEST_F(ScrollbarAnimationControllerAndroidTest,
   did_request_animate_ = false;
   EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
 
-  scrollbar_controller_->DidScrollBegin();
   EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
 
   time += base::TimeDelta::FromSeconds(1);
@@ -1798,10 +1699,10 @@ TEST_F(ScrollbarAnimationControllerAndroidTest,
   EXPECT_FLOAT_EQ(1, scrollbar_layer_->Opacity());
 
   time += base::TimeDelta::FromSeconds(1);
-  scrollbar_controller_->DidScrollEnd();
   EXPECT_FALSE(did_request_animate_);
   EXPECT_FLOAT_EQ(1, scrollbar_layer_->Opacity());
 }
 
 }  // namespace
+
 }  // namespace cc
diff --git a/chromium/cc/input/scrollbar_controller.cc b/chromium/cc/input/scrollbar_controller.cc
index aac1d4ceccd..490cd44d1d4 100644
--- a/chromium/cc/input/scrollbar_controller.cc
+++ b/chromium/cc/input/scrollbar_controller.cc
@@ -8,6 +8,7 @@
 
 #include "base/cancelable_callback.h"
 #include "cc/base/math_util.h"
+#include "cc/input/scroll_utils.h"
 #include "cc/input/scrollbar.h"
 #include "cc/input/scrollbar_controller.h"
 #include "cc/trees/layer_tree_impl.h"
@@ -35,7 +36,7 @@ void ScrollbarController::WillBeginImplFrame() {
 }
 
 // Retrieves the ScrollbarLayerImplBase corresponding to the stashed ElementId.
-ScrollbarLayerImplBase* ScrollbarController::ScrollbarLayer() {
+ScrollbarLayerImplBase* ScrollbarController::ScrollbarLayer() const {
   if (!captured_scrollbar_metadata_.has_value())
     return nullptr;
 
@@ -52,7 +53,7 @@ ScrollbarLayerImplBase* ScrollbarController::ScrollbarLayer() {
 // GSU.
 InputHandlerPointerResult ScrollbarController::HandlePointerDown(
     const gfx::PointF position_in_widget,
-    bool shift_modifier) {
+    bool jump_key_modifier) {
   LayerImpl* layer_impl = GetLayerHitByPoint(position_in_widget);
 
   // If a non-custom scrollbar layer was not found, we return early as there is
@@ -88,12 +89,15 @@ InputHandlerPointerResult ScrollbarController::HandlePointerDown(
   scroll_result.type = PointerResultType::kScrollbarScroll;
   layer_tree_host_impl_->active_tree()->UpdateScrollbarGeometries();
   const ScrollbarPart scrollbar_part =
-      GetScrollbarPartFromPointerDown(scrollbar, position_in_widget);
+      GetScrollbarPartFromPointerDown(position_in_widget);
+  const bool perform_jump_click_on_track =
+      scrollbar->JumpOnTrackClick() != jump_key_modifier;
   scroll_result.scroll_offset = GetScrollOffsetForScrollbarPart(
-      scrollbar, scrollbar_part, shift_modifier);
+      scrollbar_part, perform_jump_click_on_track);
   last_known_pointer_position_ = position_in_widget;
   scrollbar_scroll_is_active_ = true;
-  scroll_result.scroll_units = Granularity(scrollbar_part, shift_modifier);
+  scroll_result.scroll_units =
+      Granularity(scrollbar_part, perform_jump_click_on_track);
   if (scrollbar_part == ScrollbarPart::THUMB) {
     drag_state_ = DragState();
     drag_state_->drag_origin = position_in_widget;
@@ -112,12 +116,12 @@ InputHandlerPointerResult ScrollbarController::HandlePointerDown(
     // have the potential of initiating an autoscroll (if held down for long
     // enough).
     DCHECK(scrollbar_part != ScrollbarPart::THUMB);
-    cancelable_autoscroll_task_ = std::make_unique<base::CancelableOnceClosure>(
-        base::BindOnce(&ScrollbarController::StartAutoScrollAnimation,
-                       base::Unretained(this),
-                       InitialDeltaToAutoscrollVelocity(
-                           scrollbar, scroll_result.scroll_offset),
-                       scrollbar, scrollbar_part));
+    cancelable_autoscroll_task_ =
+        std::make_unique<base::CancelableOnceClosure>(base::BindOnce(
+            &ScrollbarController::StartAutoScrollAnimation,
+            base::Unretained(this),
+            InitialDeltaToAutoscrollVelocity(scroll_result.scroll_offset),
+            scrollbar_part));
     layer_tree_host_impl_->task_runner_provider()
         ->ImplThreadTaskRunner()
         ->PostDelayedTask(FROM_HERE, cancelable_autoscroll_task_->callback(),
@@ -127,16 +131,16 @@ InputHandlerPointerResult ScrollbarController::HandlePointerDown(
 }
 
 bool ScrollbarController::SnapToDragOrigin(
-    const ScrollbarLayerImplBase* scrollbar,
-    const gfx::PointF pointer_position_in_widget) {
+    const gfx::PointF pointer_position_in_widget) const {
   // Consult the ScrollbarTheme to check if thumb snapping is supported on the
   // current platform.
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
   if (!(scrollbar && scrollbar->SupportsDragSnapBack()))
     return false;
 
   bool clipped = false;
-  const gfx::PointF pointer_position_in_layer = GetScrollbarRelativePosition(
-      scrollbar, pointer_position_in_widget, &clipped);
+  const gfx::PointF pointer_position_in_layer =
+      GetScrollbarRelativePosition(pointer_position_in_widget, &clipped);
 
   if (clipped)
     return false;
@@ -189,10 +193,10 @@ bool ScrollbarController::SnapToDragOrigin(
 
 ui::ScrollGranularity ScrollbarController::Granularity(
     const ScrollbarPart scrollbar_part,
-    const bool shift_modifier) {
+    const bool jump_key_modifier) const {
   const bool shift_click_on_scrollbar_track =
-      shift_modifier && (scrollbar_part == ScrollbarPart::FORWARD_TRACK ||
-                         scrollbar_part == ScrollbarPart::BACK_TRACK);
+      jump_key_modifier && (scrollbar_part == ScrollbarPart::FORWARD_TRACK ||
+                            scrollbar_part == ScrollbarPart::BACK_TRACK);
   if (shift_click_on_scrollbar_track || scrollbar_part == ScrollbarPart::THUMB)
     return ui::ScrollGranularity::kScrollByPrecisePixel;
 
@@ -201,17 +205,17 @@ ui::ScrollGranularity ScrollbarController::Granularity(
   return ui::ScrollGranularity::kScrollByPixel;
 }
 
-float ScrollbarController::GetScrollDeltaForAbsoluteJump(
-    const ScrollbarLayerImplBase* scrollbar) {
+float ScrollbarController::GetScrollDeltaForAbsoluteJump() const {
   layer_tree_host_impl_->active_tree()->UpdateScrollbarGeometries();
 
   bool clipped = false;
-  const gfx::PointF pointer_position_in_layer = GetScrollbarRelativePosition(
-      scrollbar, last_known_pointer_position_, &clipped);
+  const gfx::PointF pointer_position_in_layer =
+      GetScrollbarRelativePosition(last_known_pointer_position_, &clipped);
 
   if (clipped)
     return 0;
 
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
   const float pointer_location =
       scrollbar->orientation() == ScrollbarOrientation::VERTICAL
           ? pointer_position_in_layer.y()
@@ -232,19 +236,18 @@ float ScrollbarController::GetScrollDeltaForAbsoluteJump(
 
   const float delta =
       round(std::abs(desired_thumb_origin - current_thumb_origin));
-  return delta * GetScrollerToScrollbarRatio(scrollbar);
+  return delta * GetScrollerToScrollbarRatio();
 }
 
 int ScrollbarController::GetScrollDeltaForDragPosition(
-    const ScrollbarLayerImplBase* scrollbar,
-    const gfx::PointF pointer_position_in_widget) {
+    const gfx::PointF pointer_position_in_widget) const {
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
   const float pointer_delta =
       scrollbar->orientation() == ScrollbarOrientation::VERTICAL
           ? pointer_position_in_widget.y() - drag_state_->drag_origin.y()
           : pointer_position_in_widget.x() - drag_state_->drag_origin.x();
 
-  const float new_offset =
-      pointer_delta * GetScrollerToScrollbarRatio(scrollbar);
+  const float new_offset = pointer_delta * GetScrollerToScrollbarRatio();
   const float scroll_delta = drag_state_->scroll_position_at_start_ +
                              new_offset - scrollbar->current_pos();
 
@@ -276,7 +279,7 @@ InputHandlerPointerResult ScrollbarController::HandlePointerMove(
   if (drag_processed_for_current_frame_)
     return scroll_result;
 
-  if (SnapToDragOrigin(scrollbar, position_in_widget)) {
+  if (SnapToDragOrigin(position_in_widget)) {
     const float delta =
         scrollbar->current_pos() - drag_state_->scroll_position_at_start_;
     scroll_result.scroll_units = ui::ScrollGranularity::kScrollByPrecisePixel;
@@ -302,7 +305,7 @@ InputHandlerPointerResult ScrollbarController::HandlePointerMove(
   // valid ScrollNode.
   DCHECK(target_node);
 
-  int delta = GetScrollDeltaForDragPosition(scrollbar, position_in_widget);
+  int delta = GetScrollDeltaForDragPosition(position_in_widget);
   if (drag_state_->scroller_length_at_previous_move !=
       scrollbar->scroll_layer_length()) {
     drag_state_->scroller_displacement = delta;
@@ -339,8 +342,7 @@ InputHandlerPointerResult ScrollbarController::HandlePointerMove(
   return scroll_result;
 }
 
-float ScrollbarController::GetScrollerToScrollbarRatio(
-    const ScrollbarLayerImplBase* scrollbar) {
+float ScrollbarController::GetScrollerToScrollbarRatio() const {
   // Calculating the delta by which the scroller layer should move when
   // dragging the thumb depends on the following factors:
   // - scrollbar_track_length
@@ -381,6 +383,7 @@ float ScrollbarController::GetScrollerToScrollbarRatio(
   //          |<- scrollbar_thumb_length ->|
   //
   layer_tree_host_impl_->active_tree()->UpdateScrollbarGeometries();
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
   float scroll_layer_length = scrollbar->scroll_layer_length();
   float scrollbar_track_length = scrollbar->TrackLength();
   gfx::Rect thumb_rect(scrollbar->ComputeThumbQuadRect());
@@ -388,7 +391,7 @@ float ScrollbarController::GetScrollerToScrollbarRatio(
       scrollbar->orientation() == ScrollbarOrientation::VERTICAL
           ? thumb_rect.height()
           : thumb_rect.width();
-  int viewport_length = GetViewportLength(scrollbar);
+  int viewport_length = GetViewportLength();
 
   return (scroll_layer_length - viewport_length) /
          (scrollbar_track_length - scrollbar_thumb_length);
@@ -399,11 +402,18 @@ void ScrollbarController::ResetState() {
   drag_state_ = base::nullopt;
   autoscroll_state_ = base::nullopt;
   captured_scrollbar_metadata_ = base::nullopt;
+  if (cancelable_autoscroll_task_) {
+    cancelable_autoscroll_task_->Cancel();
+    cancelable_autoscroll_task_.reset();
+  }
 }
 
-void ScrollbarController::DidUnregisterScrollbar(ElementId element_id) {
+void ScrollbarController::DidUnregisterScrollbar(
+    ElementId element_id,
+    ScrollbarOrientation orientation) {
   if (captured_scrollbar_metadata_.has_value() &&
-      captured_scrollbar_metadata_->scroll_element_id == element_id)
+      captured_scrollbar_metadata_->scroll_element_id == element_id &&
+      captured_scrollbar_metadata_->orientation == orientation)
     ResetState();
 }
 
@@ -413,12 +423,10 @@ void ScrollbarController::RecomputeAutoscrollStateIfNeeded() {
     return;
 
   layer_tree_host_impl_->active_tree()->UpdateScrollbarGeometries();
-  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
-  const gfx::Rect thumb_quad = scrollbar->ComputeThumbQuadRect();
 
   bool clipped;
-  gfx::PointF scroller_relative_position(GetScrollbarRelativePosition(
-      scrollbar, last_known_pointer_position_, &clipped));
+  gfx::PointF scroller_relative_position(
+      GetScrollbarRelativePosition(last_known_pointer_position_, &clipped));
 
   if (clipped)
     return;
@@ -429,6 +437,8 @@ void ScrollbarController::RecomputeAutoscrollStateIfNeeded() {
   int thumb_start = 0;
   int thumb_end = 0;
   int pointer_position = 0;
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
+  const gfx::Rect thumb_quad = scrollbar->ComputeThumbQuadRect();
   if (scrollbar->orientation() == ScrollbarOrientation::VERTICAL) {
     thumb_start = thumb_quad.y();
     thumb_end = thumb_quad.y() + thumb_quad.height();
@@ -458,7 +468,7 @@ void ScrollbarController::RecomputeAutoscrollStateIfNeeded() {
     const float scroll_layer_length = scrollbar->scroll_layer_length();
     if (autoscroll_state_->scroll_layer_length != scroll_layer_length) {
       layer_tree_host_impl_->mutator_host()->ScrollAnimationAbort();
-      StartAutoScrollAnimation(autoscroll_state_->velocity, scrollbar,
+      StartAutoScrollAnimation(autoscroll_state_->velocity,
                                autoscroll_state_->pressed_scrollbar_part);
     }
   }
@@ -466,8 +476,8 @@ void ScrollbarController::RecomputeAutoscrollStateIfNeeded() {
   // The animations need to be aborted/restarted based on the pointer location
   // (i.e leaving/entering the track/arrows, reaching the track end etc). The
   // autoscroll_state_ however, needs to be reset on pointer changes.
-  const gfx::RectF scrollbar_part_rect(GetRectForScrollbarPart(
-      scrollbar, autoscroll_state_->pressed_scrollbar_part));
+  const gfx::RectF scrollbar_part_rect(
+      GetRectForScrollbarPart(autoscroll_state_->pressed_scrollbar_part));
   if (!scrollbar_part_rect.Contains(scroller_relative_position)) {
     // Stop animating if pointer moves outside the rect bounds.
     layer_tree_host_impl_->mutator_host()->ScrollAnimationAbort();
@@ -475,17 +485,17 @@ void ScrollbarController::RecomputeAutoscrollStateIfNeeded() {
              !layer_tree_host_impl_->mutator_host()->IsElementAnimating(
                  scrollbar->scroll_element_id())) {
     // Start animating if pointer re-enters the bounds.
-    StartAutoScrollAnimation(autoscroll_state_->velocity, scrollbar,
+    StartAutoScrollAnimation(autoscroll_state_->velocity,
                              autoscroll_state_->pressed_scrollbar_part);
   }
 }
 
 // Helper to calculate the autoscroll velocity.
 float ScrollbarController::InitialDeltaToAutoscrollVelocity(
-    const ScrollbarLayerImplBase* scrollbar,
     gfx::ScrollOffset scroll_offset) const {
+  DCHECK(captured_scrollbar_metadata_.has_value());
   const float scroll_delta =
-      scrollbar->orientation() == ScrollbarOrientation::VERTICAL
+      ScrollbarLayer()->orientation() == ScrollbarOrientation::VERTICAL
           ? scroll_offset.y()
           : scroll_offset.x();
   return scroll_delta * kAutoscrollMultiplier;
@@ -493,15 +503,17 @@ float ScrollbarController::InitialDeltaToAutoscrollVelocity(
 
 void ScrollbarController::StartAutoScrollAnimation(
     const float velocity,
-    const ScrollbarLayerImplBase* scrollbar,
     ScrollbarPart pressed_scrollbar_part) {
   // Autoscroll and thumb drag are mutually exclusive. Both can't be active at
   // the same time.
   DCHECK(!drag_state_.has_value());
+  DCHECK(captured_scrollbar_metadata_.has_value());
   DCHECK_NE(velocity, 0);
+  DCHECK(ScrollbarLayer());
 
   // scroll_node is set up while handling GSB. If there's no node to scroll, we
   // don't need to create any animation for it.
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
   ScrollTree& scroll_tree =
       layer_tree_host_impl_->active_tree()->property_trees()->scroll_tree;
   ScrollNode* scroll_node =
@@ -552,18 +564,13 @@ InputHandlerPointerResult ScrollbarController::HandlePointerUp(
   if (autoscroll_state_.has_value())
     layer_tree_host_impl_->mutator_host()->ScrollAnimationAbort();
 
-  if (cancelable_autoscroll_task_) {
-    cancelable_autoscroll_task_->Cancel();
-    cancelable_autoscroll_task_.reset();
-  }
-
   ResetState();
   return scroll_result;
 }
 
 // Returns the layer that is hit by the position_in_widget.
 LayerImpl* ScrollbarController::GetLayerHitByPoint(
-    const gfx::PointF position_in_widget) {
+    const gfx::PointF position_in_widget) const {
   LayerTreeImpl* active_tree = layer_tree_host_impl_->active_tree();
   gfx::Point viewport_point(position_in_widget.x(), position_in_widget.y());
 
@@ -575,8 +582,8 @@ LayerImpl* ScrollbarController::GetLayerHitByPoint(
   return layer_impl;
 }
 
-int ScrollbarController::GetViewportLength(
-    const ScrollbarLayerImplBase* scrollbar) const {
+int ScrollbarController::GetViewportLength() const {
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
   const ScrollNode* scroll_node =
       layer_tree_host_impl_->active_tree()
           ->property_trees()
@@ -587,30 +594,51 @@ int ScrollbarController::GetViewportLength(
              : scroll_node->container_bounds.width();
 }
 
+int ScrollbarController::GetScrollDeltaForPercentBasedScroll() const {
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
+
+  const ScrollNode* scroll_node =
+      layer_tree_host_impl_->active_tree()
+          ->property_trees()
+          ->scroll_tree.FindNodeFromElementId(scrollbar->scroll_element_id());
+  DCHECK(scroll_node);
+
+  const gfx::Vector2dF scroll_delta =
+      scrollbar->orientation() == ScrollbarOrientation::VERTICAL
+          ? gfx::Vector2dF(0, kPercentDeltaForDirectionalScroll)
+          : gfx::Vector2dF(kPercentDeltaForDirectionalScroll, 0);
+
+  const gfx::Vector2dF pixel_delta =
+      layer_tree_host_impl_->ResolveScrollGranularityToPixels(
+          *scroll_node, scroll_delta,
+          ui::ScrollGranularity::kScrollByPercentage);
+
+  return scrollbar->orientation() == ScrollbarOrientation::VERTICAL
+             ? pixel_delta.y()
+             : pixel_delta.x();
+}
+
 int ScrollbarController::GetScrollDeltaForScrollbarPart(
-    const ScrollbarLayerImplBase* scrollbar,
     const ScrollbarPart scrollbar_part,
-    const bool shift_modifier) {
+    const bool jump_key_modifier) const {
   int scroll_delta = 0;
 
   switch (scrollbar_part) {
     case ScrollbarPart::BACK_BUTTON:
     case ScrollbarPart::FORWARD_BUTTON:
       if (layer_tree_host_impl_->settings().percent_based_scrolling) {
-        scroll_delta =
-            kPercentDeltaForDirectionalScroll * GetViewportLength(scrollbar);
+        scroll_delta = GetScrollDeltaForPercentBasedScroll();
       } else {
         scroll_delta = kPixelsPerLineStep * ScreenSpaceScaleFactor();
       }
       break;
     case ScrollbarPart::BACK_TRACK:
     case ScrollbarPart::FORWARD_TRACK: {
-      if (shift_modifier) {
-        scroll_delta = GetScrollDeltaForAbsoluteJump(scrollbar);
+      if (jump_key_modifier) {
+        scroll_delta = GetScrollDeltaForAbsoluteJump();
         break;
       }
-      scroll_delta =
-          GetViewportLength(scrollbar) * kMinFractionToStepWhenPaging;
+      scroll_delta = GetViewportLength() * kMinFractionToStepWhenPaging;
       break;
     }
     default:
@@ -634,9 +662,8 @@ float ScrollbarController::ScreenSpaceScaleFactor() const {
 }
 
 gfx::PointF ScrollbarController::GetScrollbarRelativePosition(
-    const ScrollbarLayerImplBase* scrollbar,
     const gfx::PointF position_in_widget,
-    bool* clipped) {
+    bool* clipped) const {
   gfx::Transform inverse_screen_space_transform(
       gfx::Transform::kSkipInitialization);
 
@@ -647,7 +674,7 @@ gfx::PointF ScrollbarController::GetScrollbarRelativePosition(
           ? 1.f / layer_tree_host_impl_->active_tree()->device_scale_factor()
           : 1.f;
   gfx::Transform scaled_screen_space_transform(
-      scrollbar->ScreenSpaceTransform());
+      ScrollbarLayer()->ScreenSpaceTransform());
   scaled_screen_space_transform.PostScale(scale, scale);
   if (!scaled_screen_space_transform.GetInverse(
           &inverse_screen_space_transform))
@@ -659,14 +686,14 @@ gfx::PointF ScrollbarController::GetScrollbarRelativePosition(
 
 // Determines the ScrollbarPart based on the position_in_widget.
 ScrollbarPart ScrollbarController::GetScrollbarPartFromPointerDown(
-    const ScrollbarLayerImplBase* scrollbar,
-    const gfx::PointF position_in_widget) {
+    const gfx::PointF position_in_widget) const {
   // position_in_widget needs to be transformed and made relative to the
   // scrollbar layer because hit testing assumes layer relative coordinates.
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
   bool clipped = false;
 
   const gfx::PointF scroller_relative_position(
-      GetScrollbarRelativePosition(scrollbar, position_in_widget, &clipped));
+      GetScrollbarRelativePosition(position_in_widget, &clipped));
 
   if (clipped)
     return ScrollbarPart::NO_PART;
@@ -676,8 +703,8 @@ ScrollbarPart ScrollbarController::GetScrollbarPartFromPointerDown(
 
 // Determines the corresponding rect for the given scrollbar part.
 gfx::Rect ScrollbarController::GetRectForScrollbarPart(
-    const ScrollbarLayerImplBase* scrollbar,
-    const ScrollbarPart scrollbar_part) {
+    const ScrollbarPart scrollbar_part) const {
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
   if (scrollbar_part == ScrollbarPart::BACK_BUTTON)
     return scrollbar->BackButtonRect();
   if (scrollbar_part == ScrollbarPart::FORWARD_BUTTON)
@@ -692,11 +719,11 @@ gfx::Rect ScrollbarController::GetRectForScrollbarPart(
 // Determines the scroll offsets based on the ScrollbarPart and the scrollbar
 // orientation.
 gfx::ScrollOffset ScrollbarController::GetScrollOffsetForScrollbarPart(
-    const ScrollbarLayerImplBase* scrollbar,
     const ScrollbarPart scrollbar_part,
-    const bool shift_modifier) {
+    const bool jump_key_modifier) const {
+  const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer();
   float scroll_delta =
-      GetScrollDeltaForScrollbarPart(scrollbar, scrollbar_part, shift_modifier);
+      GetScrollDeltaForScrollbarPart(scrollbar_part, jump_key_modifier);
 
   // See CreateScrollStateForGesture for more information on how these values
   // will be interpreted.
diff --git a/chromium/cc/input/scrollbar_controller.h b/chromium/cc/input/scrollbar_controller.h
index 4177c3464e5..ebe4dde9f09 100644
--- a/chromium/cc/input/scrollbar_controller.h
+++ b/chromium/cc/input/scrollbar_controller.h
@@ -119,24 +119,31 @@ class CC_EXPORT ScrollbarController {
   explicit ScrollbarController(LayerTreeHostImpl*);
   virtual ~ScrollbarController();
 
+  // On Mac, the "jump to the spot that's clicked" setting can be dynamically
+  // set via System Preferences. When enabled, the expectation is that regular
+  // clicks on the scrollbar should make the scroller "jump" to the clicked
+  // location rather than animated scrolling. Additionally, when this is enabled
+  // and the user does an Option + click on the scrollbar, the scroller should
+  // *not* jump to that spot (i.e it should be treated as a regular track
+  // click). When this setting is disabled on the Mac, Option + click should
+  // make the scroller jump and a regular click should animate the scroll
+  // offset. On all other platforms, the "jump on click" option is available
+  // (via Shift + click) but is not configurable.
   InputHandlerPointerResult HandlePointerDown(
       const gfx::PointF position_in_widget,
-      const bool shift_modifier);
+      const bool jump_key_modifier);
   InputHandlerPointerResult HandlePointerMove(
       const gfx::PointF position_in_widget);
   InputHandlerPointerResult HandlePointerUp(
       const gfx::PointF position_in_widget);
 
-  // "velocity" here is calculated based on the initial scroll delta (See
-  // InitialDeltaToAutoscrollVelocity). This value carries a "sign" which is
-  // needed to determine whether we should set up the autoscrolling in the
-  // forwards or the backwards direction.
-  void StartAutoScrollAnimation(float velocity,
-                                const ScrollbarLayerImplBase* scrollbar,
-                                ScrollbarPart pressed_scrollbar_part);
-  bool ScrollbarScrollIsActive() { return scrollbar_scroll_is_active_; }
-  void DidUnregisterScrollbar(ElementId element_id);
-  ScrollbarLayerImplBase* ScrollbarLayer();
+  bool AutoscrollTaskIsScheduled() const {
+    return cancelable_autoscroll_task_ != nullptr;
+  }
+  bool ScrollbarScrollIsActive() const { return scrollbar_scroll_is_active_; }
+  void DidUnregisterScrollbar(ElementId element_id,
+                              ScrollbarOrientation orientation);
+  ScrollbarLayerImplBase* ScrollbarLayer() const;
   void WillBeginImplFrame();
   void ResetState();
 
@@ -187,44 +194,42 @@ class CC_EXPORT ScrollbarController {
     ScrollbarOrientation orientation;
   };
 
+  // "velocity" here is calculated based on the initial scroll delta (See
+  // InitialDeltaToAutoscrollVelocity). This value carries a "sign" which is
+  // needed to determine whether we should set up the autoscrolling in the
+  // forwards or the backwards direction.
+  void StartAutoScrollAnimation(float velocity,
+                                ScrollbarPart pressed_scrollbar_part);
+
   // Returns the DSF based on whether use-zoom-for-dsf is enabled.
   float ScreenSpaceScaleFactor() const;
 
   // Helper to convert scroll offset to autoscroll velocity.
-  float InitialDeltaToAutoscrollVelocity(
-      const ScrollbarLayerImplBase* scrollbar,
-      gfx::ScrollOffset scroll_offset) const;
+  float InitialDeltaToAutoscrollVelocity(gfx::ScrollOffset scroll_offset) const;
 
   // Returns the hit tested ScrollbarPart based on the position_in_widget.
   ScrollbarPart GetScrollbarPartFromPointerDown(
-      const ScrollbarLayerImplBase* scrollbar,
-      const gfx::PointF position_in_widget);
+      const gfx::PointF position_in_widget) const;
 
   // Returns scroll offsets based on which ScrollbarPart was hit tested.
   gfx::ScrollOffset GetScrollOffsetForScrollbarPart(
-      const ScrollbarLayerImplBase* scrollbar,
       const ScrollbarPart scrollbar_part,
-      const bool shift_modifier);
+      const bool jump_key_modifier) const;
 
   // Returns the rect for the ScrollbarPart.
-  gfx::Rect GetRectForScrollbarPart(const ScrollbarLayerImplBase* scrollbar,
-                                    const ScrollbarPart scrollbar_part);
+  gfx::Rect GetRectForScrollbarPart(const ScrollbarPart scrollbar_part) const;
 
-  LayerImpl* GetLayerHitByPoint(const gfx::PointF position_in_widget);
-  int GetScrollDeltaForScrollbarPart(const ScrollbarLayerImplBase* scrollbar,
-                                     const ScrollbarPart scrollbar_part,
-                                     const bool shift_modifier);
+  LayerImpl* GetLayerHitByPoint(const gfx::PointF position_in_widget) const;
+  int GetScrollDeltaForScrollbarPart(const ScrollbarPart scrollbar_part,
+                                     const bool jump_key_modifier) const;
 
   // Makes position_in_widget relative to the scrollbar.
-  gfx::PointF GetScrollbarRelativePosition(
-      const ScrollbarLayerImplBase* scrollbar,
-      const gfx::PointF position_in_widget,
-      bool* clipped);
+  gfx::PointF GetScrollbarRelativePosition(const gfx::PointF position_in_widget,
+                                           bool* clipped) const;
 
   // Decides if the scroller should snap to the offset that it was originally at
   // (i.e the offset before the thumb drag).
-  bool SnapToDragOrigin(const ScrollbarLayerImplBase* scrollbar,
-                        const gfx::PointF pointer_position_in_widget);
+  bool SnapToDragOrigin(const gfx::PointF pointer_position_in_widget) const;
 
   // Decides whether a track autoscroll should be aborted (or restarted) due to
   // the thumb reaching the pointer or the pointer leaving (or re-entering) the
@@ -233,22 +238,24 @@ class CC_EXPORT ScrollbarController {
 
   // Shift (or "Option" in case of Mac) + click is expected to do a non-animated
   // jump to a certain offset.
-  float GetScrollDeltaForAbsoluteJump(const ScrollbarLayerImplBase* scrollbar);
+  float GetScrollDeltaForAbsoluteJump() const;
 
   // Determines if the delta needs to be animated.
   ui::ScrollGranularity Granularity(const ScrollbarPart scrollbar_part,
-                                    bool shift_modifier);
+                                    bool jump_key_modifier) const;
 
   // Calculates the delta based on position_in_widget and drag_origin.
   int GetScrollDeltaForDragPosition(
-      const ScrollbarLayerImplBase* scrollbar,
-      const gfx::PointF pointer_position_in_widget);
+      const gfx::PointF pointer_position_in_widget) const;
 
   // Returns the ratio of the scroller length to the scrollbar length. This is
   // needed to scale the scroll delta for thumb drag.
-  float GetScrollerToScrollbarRatio(const ScrollbarLayerImplBase* scrollbar);
+  float GetScrollerToScrollbarRatio() const;
+
+  int GetViewportLength() const;
 
-  int GetViewportLength(const ScrollbarLayerImplBase* scrollbar) const;
+  // Returns the pixel delta for a percent-based scroll of the scrollbar
+  int GetScrollDeltaForPercentBasedScroll() const;
 
   LayerTreeHostImpl* layer_tree_host_impl_;
 
diff --git a/chromium/cc/input/touch_action.h b/chromium/cc/input/touch_action.h
index f00d263acea..e873bd02d62 100644
--- a/chromium/cc/input/touch_action.h
+++ b/chromium/cc/input/touch_action.h
@@ -8,7 +8,7 @@
 #include <cstdlib>
 #include <string>
 
-#include "base/logging.h"
+#include "base/notreached.h"
 
 namespace cc {