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) {
+    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