Basic ScrollTimeline implementation for Animation Worklet

third_party/WebKit/Source/core/animation/ScrollTimeline.cpp

+// Copyright 2017 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 "core/animation/ScrollTimeline.h"
+
+#include "core/dom/ExceptionCode.h"
+#include "core/layout/LayoutBox.h"
+#include "core/paint/PaintLayerScrollableArea.h"
+
+namespace blink {
+
+namespace {
+bool StringToScrollDirection(String scroll_direction,
+                             ScrollTimeline::ScrollDirection* result) {
+  if (scroll_direction == "auto") {
+    *result = ScrollTimeline::Auto;
+    return true;
+  }
+  if (scroll_direction == "block") {
+    *result = ScrollTimeline::Block;
+    return true;
+  }
+  if (scroll_direction == "inline") {
+    *result = ScrollTimeline::Inline;
+    return true;
+  }
+  return false;
+}
+}  // namespace
+
+ScrollTimeline* ScrollTimeline::Create(const Document& document,
+                                       ScrollTimelineOptions options,
+                                       ExceptionState& exception_state) {
+  Element* scroll_source =
+      options.scrollSource()
+          ? options.scrollSource()
+          : const_cast<Document&>(document).scrollingElement();

[majidvp, 2017/05/17 20:39:45]

I believe this should instead use |ScrollingElementNoLayout()| as indicated in
the respective comments.

[majidvp, 2017/05/17 20:39:45]

It is odd that this method is not |const| requiring you to cast! Can we make it
const?

[smcgruer, 2017/05/18 13:58:56]

My only concern here is that |scrollingElement()| will do layout, whilst
|ScrollingElementNoLayout()| has a pre-requisite that you have already done
layout or it will DCHECK. I don't think that assumption is valid since the user
can create this class from script?
Feasible to do for |ScrollingElementNoLayout()| I think, but not for
|scrollingElement()|. The latter calls |UpdateStyleAndLayoutTree()| which is
sensibly non-const. So depends on resolution of above comment.

[smcgruer, 2017/05/18 14:17:21]

Turns out that the Document& doesnt have to be const when called from JS, so
fixed the const issue.

+
+  ScrollDirection orientation;
+  if (!StringToScrollDirection(options.orientation(), &orientation)) {
+    exception_state.ThrowDOMException(kNotSupportedError,
+                                      "Invalid orientation");
+    return nullptr;
+  }
+
+  // TODO(smcgruer): Support 'auto' value.
+  if (options.timeRange().isScrollTimelineAutoKeyword()) {
+    exception_state.ThrowDOMException(
+        kNotSupportedError, "'auto' value for timeRange not yet supported");
+    return nullptr;
+  }
+
+  return new ScrollTimeline(document, scroll_source, orientation,
+                            options.timeRange().getAsDouble());
+}
+
+ScrollTimeline::ScrollTimeline(const Document& document,
+                               Element* scroll_source,
+                               ScrollDirection orientation,
+                               double time_range)
+    : AnimationTimeline(const_cast<Document*>(&document), nullptr),
+      scroll_source_(scroll_source),
+      orientation_(orientation),
+      time_range_(time_range) {}
+
+double ScrollTimeline::currentTime(bool& is_null) {
+  // 1. If scrollSource does not currently have a CSS layout box, or if its
+  // layout box is not a scroll container, return an unresolved time value.
+  LayoutBox* layout_box = scroll_source_->GetLayoutBox();
+  if (!layout_box || !layout_box->HasOverflowClip()) {
+    is_null = true;
+    return std::numeric_limits<double>::quiet_NaN();
+  }
+
+  // 2. Otherwise, let current scroll offset be the current scroll offset of
+  // scrollSource in the direction specified by orientation.
+
+  // 'auto' ScrollDirection is specified as: If only one direction is
+  // scrollable, selects that direction. Otherwise selects the direction along
+  // the block axis.
+  ScrollDirection local_orientation = orientation_;
+  bool is_horizontal = layout_box->IsHorizontalWritingMode();
+  if (local_orientation == Auto) {
+    if (layout_box->HasScrollableOverflowX() &&
+        !layout_box->HasScrollableOverflowY()) {
+      local_orientation = is_horizontal ? Inline : Block;
+    } else if (!layout_box->HasScrollableOverflowX() &&
+               layout_box->HasScrollableOverflowY()) {
+      local_orientation = is_horizontal ? Block : Inline;
+    } else {
+      // Either neither or both axes are scrollable, so select the block
+      // direction.
+      local_orientation = Block;
+    }
+  }

[majidvp, 2017/05/17 20:39:45]

Should this decision be made every time we query currentTime 
or only at timeline construction time. e.g., if I change the writing mode or my
overflow direction during the
animation. All of sudden we are linked to a different scroll orientation.

Spec [1] indicates to use the direction specified by the orientation during the
current time algorithm but not clear it mean resolving "auto" every time.

[1] https://wicg.github.io/scroll-animations/#current-time-algorithm

[smcgruer, 2017/05/18 13:58:56]

Filed https://github.com/WICG/scroll-animations/issues/15 to ask. My
interpretation is that it should be resolved each time, but best to just get a
clarification :)

[smcgruer, 2017/05/23 14:47:27]

https://github.com/WICG/scroll-animations/issues/15 specified that it should be
at construction time, but then I discovered
https://github.com/WICG/scroll-animations/issues/16 which makes it difficult to
implement orientation == 'auto' at this time. Therefore, I decided to just
disallow orientation == 'auto' for now.

+
+  // Depending on the writing-mode and direction, the scroll origin shifts and
+  // the scroll offset may be negative. The easiest way to deal with this is to
+  // use only the magnitude of the scroll offset, and compare it to (max-offset
+  // - min_offset).
+  PaintLayerScrollableArea* scrollable_area = layout_box->GetScrollableArea();
+  ScrollOffset abs_scroll_offset =
+      ScrollOffset(std::abs(scrollable_area->GetScrollOffset().Width()),
+                   std::abs(scrollable_area->GetScrollOffset().Height()));
+  ScrollOffset max_abs_scroll_offset = scrollable_area->MaximumScrollOffset() -

[majidvp, 2017/05/17 20:39:45]

nit: s/max_abs_scroll_offset/scroll_dimensions/  (or scroll_size?)

[smcgruer, 2017/05/18 13:58:56]

Done.

+                                       scrollable_area->MinimumScrollOffset();
+
+  double current_offset;
+  double max_offset;
+  DCHECK(local_orientation == Block || local_orientation == Inline);
+  if (local_orientation == Block) {
+    current_offset =
+        is_horizontal ? abs_scroll_offset.Height() : abs_scroll_offset.Width();
+    max_offset = is_horizontal ? max_abs_scroll_offset.Height()
+                               : max_abs_scroll_offset.Width();
+  } else {
+    current_offset =
+        is_horizontal ? abs_scroll_offset.Width() : abs_scroll_offset.Height();
+    max_offset = is_horizontal ? max_abs_scroll_offset.Width()
+                               : max_abs_scroll_offset.Height();
+  }
+
+  // 3. If current scroll offset is less than startScrollOffset, return an
+  // unresolved time value if fill is none or forwards, or 0 otherwise.
+  // TODO(smcgruer): Implement |startScrollOffset| and |fill|.
+
+  // 4. If current scroll offset is greater than or equal to endScrollOffset,
+  // return an unresolved time value if fill is none or backwards, or the
+  // effective time range otherwise.
+  // TODO(smcgruer): Implement |endScrollOffset| and |fill|.
+
+  // 5. Return the result of evaluating the following expression:
+  //   ((current scroll offset - startScrollOffset) /
+  //      (endScrollOffset - startScrollOffset)) * effective time range
+
+  is_null = false;
+  return (current_offset / max_offset) * time_range_;

[majidvp, 2017/05/17 20:39:44]

may be cleaner if we just move std::abs operation down here?

[smcgruer, 2017/05/18 13:58:56]

Done.

+}
+
+double ScrollTimeline::currentTime() {
+  bool ignored;
+  return currentTime(ignored);
+}
+
+double ScrollTimeline::CurrentTimeInternal(bool& is_null) {
+  return currentTime(is_null);
+}
+
+double ScrollTimeline::CurrentTimeInternal() {
+  bool ignored;
+  return currentTime(ignored);
+}
+
+Element* ScrollTimeline::scrollSource() {
+  return scroll_source_.Get();
+}
+
+String ScrollTimeline::orientation() {
+  switch (orientation_) {
+    case Auto:
+      return "auto";

[majidvp, 2017/05/17 20:39:45]

If we decide to resolve "auto" value on construction then it may make
sense to return the resolved value here. It will be more useful.

+    case Block:
+      return "block";
+    case Inline:
+      return "inline";
+  }
+}
+
+void ScrollTimeline::timeRange(DoubleOrScrollTimelineAutoKeyword& result) {
+  result.setDouble(time_range_);
+}
+
+DEFINE_TRACE(ScrollTimeline) {
+  visitor->Trace(scroll_source_);
+  AnimationTimeline::Trace(visitor);
+}
+
+}  // namespace blink