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) {
+  // TODO(smcgruer): The spec allows for a null scrollSource.

[majidvp, 2017/05/15 14:38:52]

Hmmm, I presume that if the scrollSource is not specified then the timeline can
be considered "inactive" and return an unresolved time value. wdyt?

https://w3c.github.io/web-animations/#inactive-timeline

[smcgruer, 2017/05/15 15:22:54]

Nope, spec defines it as follows
(https://wicg.github.io/scroll-animations/#dom-scrolltimeline-scrollsource):

"If [the scrollSource] is not specified, the document element of the active
document for the current browsing context, as determined at the time the
ScrollTimeline is constructed, is used."

[flackr, 2017/05/15 17:29:06]

Note, probably should be the document.scrollingElement of the active document.

[smcgruer, 2017/05/16 19:24:47]

Filed https://github.com/WICG/scroll-animations/issues/14 for the spec issue,
made code use the document scrolling element.

+  if (!options.scrollSource()) {
+    exception_state.ThrowDOMException(kNotSupportedError,
+                                      "A scrollSource must be specified");
+    return nullptr;
+  }
+
+  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 new ScrollTimeline(document, options.scrollSource(), 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->GetScrollableArea()) {

[majidvp, 2017/05/15 14:38:52]

I don't think layout_box->GetScrollableArea() maps correctly to existence of
scroll container. At the moment we create a scrollable area for any layout box
[1]. 

Also note that an element with overflow:auto is considered an scroll container
[2] even if it is not currently overflowing.

[1]
https://codesearch.chromium.org/chromium/src/third_party/WebKit/Source/core/p...
[2] https://www.w3.org/TR/css-overflow-3/#scroll-container

[smcgruer, 2017/05/15 15:22:54]

Ah, so looks like by the spec we just want to check the value of overflow for
the element? I'm sure there must be a function somewhere to do that...

[flackr, 2017/05/15 17:29:06]

LayoutObject::HasOverflowClip

[smcgruer, 2017/05/16 19:24:47]

Done.

+    LOG(INFO) << "!layout_box || !layout_box->GetScrollableArea()";
+    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.
+  ScrollDirection local_orientation = orientation_;
+  if (local_orientation == Auto) {
+    // If only one direction is scrollable, selects that direction. Otherwise
+    // selects the direction along the block axis.
+    DCHECK(layout_box->HasScrollableOverflowX() ||
+           layout_box->HasScrollableOverflowY());

[flackr, 2017/05/15 17:29:06]

I don't think this check is correct. We could have a scroll source that does not
overflow in either direction. This would be expected to produce the end value if
fill forwards is specified or unresolved if not.
https://wicg.github.io/scroll-animations/#current-time-algorithm

[smcgruer, 2017/05/17 15:52:03]

Done.

+    local_orientation = layout_box->HasScrollableOverflowY() ? Block : Inline;

[flackr, 2017/05/15 17:29:06]

Isn't this assuming LTR? I think you'd have to check the current writing mode to
know which direction is block and which is inline.

[smcgruer, 2017/05/17 15:52:02]

Done.

+  }
+  double current_scroll_offset = 0.0;
+  double max_scroll_offset = 1.0;
+  switch (local_orientation) {
+    case Block:
+      current_scroll_offset = scroll_source_->scrollTop();
+      max_scroll_offset =
+          scroll_source_->scrollHeight() - scroll_source_->clientHeight();

[majidvp, 2017/05/15 14:38:52]

Shouldn't we use the logical coordinates here as opposed to the physical one. I
thought a vertical writing mode flips height and width dimensions which can make
this incorrect.

[smcgruer, 2017/05/15 15:22:54]

Possibly. I just wrote this based on a comment in
https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight :

"The following equivalence returns true if an element is at the end of its
scroll, false if it isn't.

element.scrollHeight - element.scrollTop === element.clientHeight"


I will check out vertical writing modes.

[smcgruer, 2017/05/17 15:52:02]

Done.

+      break;
+    case Inline:
+      current_scroll_offset = scroll_source_->scrollLeft();
+      max_scroll_offset =
+          scroll_source_->scrollWidth() - scroll_source_->clientWidth();
+      break;
+    case Auto:
+      LOG(FATAL) << "local_orientation cannot be Auto";
+      break;
+  }
+
+  // 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_scroll_offset / max_scroll_offset) * time_range_;
+}
+
+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";
+    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