Implement Element.scrollIntoView for scroll-behavior: smooth.

third_party/WebKit/Source/platform/scroll/ScrollableArea.cpp

 /*
  * Copyright (c) 2010, Google Inc. All rights reserved.
  * Copyright (C) 2008, 2011 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 19 matching lines @@
  */
 
 #include "platform/scroll/ScrollableArea.h"
 
 #include "platform/PlatformChromeClient.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/scroll/MainThreadScrollingReason.h"
 #include "platform/scroll/ProgrammaticScrollAnimator.h"
 #include "platform/scroll/ScrollbarTheme.h"
+#include "platform/scroll/SmoothScrollSequencer.h"
 
 static const int kPixelsPerLineStep = 40;
 static const float kMinFractionToStepWhenPaging = 0.875f;
 
 namespace blink {
 
 int ScrollableArea::PixelsPerLineStep(PlatformChromeClient* host) {
   if (!host)
     return kPixelsPerLineStep;
   return host->WindowToViewportScalar(kPixelsPerLineStep);
@@ skipping 97 matching lines @@
   ScrollOffset scrollable_axis_delta(
       UserInputScrollable(kHorizontalScrollbar) ? pixel_delta.Width() : 0,
       UserInputScrollable(kVerticalScrollbar) ? pixel_delta.Height() : 0);
 
   if (scrollable_axis_delta.IsZero()) {
     return ScrollResult(false, false, pixel_delta.Width(),
                         pixel_delta.Height());
   }
 
   CancelProgrammaticScrollAnimation();
+  if (SmoothScrollSequencer* sequencer = GetSmoothScrollSequencer())
+    sequencer->AbortAnimations();
 
   ScrollResult result =
       GetScrollAnimator().UserScroll(granularity, pixel_delta);
 
   // Delta that wasn't scrolled because the axis is !userInputScrollable
   // should count as unusedScrollDelta.
   ScrollOffset unscrollable_axis_delta = pixel_delta - scrollable_axis_delta;
   result.unused_scroll_delta_x += unscrollable_axis_delta.Width();
   result.unused_scroll_delta_y += unscrollable_axis_delta.Height();
 
   return result;
 }
 
 void ScrollableArea::SetScrollOffset(const ScrollOffset& offset,
                                      ScrollType scroll_type,
                                      ScrollBehavior behavior) {
+  if (scroll_type != kSequencedSmoothScroll && scroll_type != kClampingScroll &&
+      scroll_type != kAnchoringScroll) {

[bokan, 2017/06/07 17:56:00]

just FYI: I'm not sure how anchoring scrolls should interact with this since a
scroll anchor could change the location of the thing we're trying to scroll into
view. But stopping the scroll into view doesn't sound good to me either and
trying to recalculate on the fly sounds incredibly complex for what should be an
edge case so I think  this is fine unless we find it doesn't work well in
practice.

[sunyunjia, 2017/06/07 18:34:10]

Acknowledged.

+    if (SmoothScrollSequencer* sequencer = GetSmoothScrollSequencer())
+      sequencer->AbortAnimations();
+  }
+
   ScrollOffset clamped_offset = ClampScrollOffset(offset);
   if (clamped_offset == GetScrollOffset())
     return;
 
   if (behavior == kScrollBehaviorAuto)
     behavior = ScrollBehaviorStyle();
 
   switch (scroll_type) {
     case kCompositorScroll:
     case kClampingScroll:
       ScrollOffsetChanged(clamped_offset, scroll_type);
       break;
     case kAnchoringScroll:
       GetScrollAnimator().AdjustAnimationAndSetScrollOffset(clamped_offset,
                                                             scroll_type);
       break;
     case kProgrammaticScroll:
-      ProgrammaticScrollHelper(clamped_offset, behavior);
+      ProgrammaticScrollHelper(clamped_offset, behavior, false);
+      break;
+    case kSequencedSmoothScroll:
+      ProgrammaticScrollHelper(clamped_offset, behavior, true);
       break;
     case kUserScroll:
       UserScrollHelper(clamped_offset, behavior);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void ScrollableArea::ScrollBy(const ScrollOffset& delta,
@@ skipping 14 matching lines @@
     new_offset =
         ScrollOffset(GetScrollAnimator().CurrentOffset().Width(), offset);
 
   // TODO(bokan): Note, this doesn't use the derived class versions since this
   // method is currently used exclusively by code that adjusts the position by
   // the scroll origin and the derived class versions differ on whether they
   // take that into account or not.
   ScrollableArea::SetScrollOffset(new_offset, scroll_type, behavior);
 }
 
-void ScrollableArea::ProgrammaticScrollHelper(const ScrollOffset& offset,
-                                              ScrollBehavior scroll_behavior) {
+void ScrollableArea::ProgrammaticScrollHelper(
+    const ScrollOffset& offset,
+    ScrollBehavior scroll_behavior,
+    bool sequenced_for_smooth_scroll) {
   CancelScrollAnimation();
 
-  if (scroll_behavior == kScrollBehaviorSmooth)
-    GetProgrammaticScrollAnimator().AnimateToOffset(offset);
-  else
+  if (scroll_behavior == kScrollBehaviorSmooth) {
+    GetProgrammaticScrollAnimator().AnimateToOffset(
+        offset, sequenced_for_smooth_scroll);
+  } else {
     GetProgrammaticScrollAnimator().ScrollToOffsetWithoutAnimation(offset);
+  }
 }
 
 void ScrollableArea::UserScrollHelper(const ScrollOffset& offset,
                                       ScrollBehavior scroll_behavior) {
   CancelProgrammaticScrollAnimation();
+  if (SmoothScrollSequencer* sequencer = GetSmoothScrollSequencer())
+    sequencer->AbortAnimations();
 
   float x = UserInputScrollable(kHorizontalScrollbar)
                 ? offset.Width()
                 : GetScrollAnimator().CurrentOffset().Width();
   float y = UserInputScrollable(kVerticalScrollbar)
                 ? offset.Height()
                 : GetScrollAnimator().CurrentOffset().Height();
 
   // Smooth user scrolls (keyboard, wheel clicks) are handled via the userScroll
   // method.
   // TODO(bokan): The userScroll method should probably be modified to call this
   //              method and ScrollAnimatorBase to have a simpler
   //              animateToOffset method like the ProgrammaticScrollAnimator.
   DCHECK_EQ(scroll_behavior, kScrollBehaviorInstant);
   GetScrollAnimator().ScrollToOffsetWithoutAnimation(ScrollOffset(x, y));
 }
 
 LayoutRect ScrollableArea::ScrollIntoView(const LayoutRect& rect_in_content,
                                           const ScrollAlignment& align_x,
                                           const ScrollAlignment& align_y,
+                                          bool is_smooth,
                                           ScrollType) {
   // TODO(bokan): This should really be implemented here but ScrollAlignment is
   // in Core which is a dependency violation.
   NOTREACHED();
   return LayoutRect();
 }
 
 void ScrollableArea::ScrollOffsetChanged(const ScrollOffset& offset,
                                          ScrollType scroll_type) {
   TRACE_EVENT0("blink", "ScrollableArea::scrollOffsetChanged");
@@ skipping 403 matching lines @@
                                          offset.y() - ScrollOrigin().Y());
   SetScrollOffset(new_offset, kCompositorScroll);
 }
 
 DEFINE_TRACE(ScrollableArea) {
   visitor->Trace(scroll_animator_);
   visitor->Trace(programmatic_scroll_animator_);
 }
 
 }  // namespace blink