Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 166 insertions, 0 deletions

diff --git a/dom/animation/ViewTimeline.cpp b/dom/animation/ViewTimeline.cpp
new file mode 100644
index 0000000000..5727c5f08e
--- /dev/null
+++ b/dom/animation/ViewTimeline.cpp
@@ -0,0 +1,166 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "ViewTimeline.h"
+
+#include "mozilla/dom/Animation.h"
+#include "mozilla/dom/ElementInlines.h"
+#include "nsIScrollableFrame.h"
+#include "nsLayoutUtils.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(ViewTimeline, ScrollTimeline, mSubject)
+NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(ViewTimeline, ScrollTimeline)
+
+/* static */
+already_AddRefed<ViewTimeline> ViewTimeline::MakeNamed(
+    Document* aDocument, Element* aSubject, PseudoStyleType aPseudoType,
+    const StyleViewTimeline& aStyleTimeline) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // 1. Lookup scroller. We have to find the nearest scroller from |aSubject|
+  // and |aPseudoType|.
+  auto [element, pseudo] = FindNearestScroller(aSubject, aPseudoType);
+  auto scroller = Scroller::Nearest(const_cast<Element*>(element), pseudo);
+
+  // 2. Create timeline.
+  return MakeAndAddRef<ViewTimeline>(aDocument, scroller,
+                                     aStyleTimeline.GetAxis(), aSubject,
+                                     aPseudoType, aStyleTimeline.GetInset());
+}
+
+/* static */
+already_AddRefed<ViewTimeline> ViewTimeline::MakeAnonymous(
+    Document* aDocument, const NonOwningAnimationTarget& aTarget,
+    StyleScrollAxis aAxis, const StyleViewTimelineInset& aInset) {
+  // view() finds the nearest scroll container from the animation target.
+  auto [element, pseudo] =
+      FindNearestScroller(aTarget.mElement, aTarget.mPseudoType);
+  Scroller scroller = Scroller::Nearest(const_cast<Element*>(element), pseudo);
+  return MakeAndAddRef<ViewTimeline>(aDocument, scroller, aAxis,
+                                     aTarget.mElement, aTarget.mPseudoType,
+                                     aInset);
+}
+
+void ViewTimeline::ReplacePropertiesWith(Element* aSubjectElement,
+                                         PseudoStyleType aPseudoType,
+                                         const StyleViewTimeline& aNew) {
+  mSubject = aSubjectElement;
+  mSubjectPseudoType = aPseudoType;
+  mAxis = aNew.GetAxis();
+  // FIXME: Bug 1817073. We assume it is a non-animatable value for now.
+  mInset = aNew.GetInset();
+
+  for (auto* anim = mAnimationOrder.getFirst(); anim;
+       anim = static_cast<LinkedListElement<Animation>*>(anim)->getNext()) {
+    MOZ_ASSERT(anim->GetTimeline() == this);
+    // Set this so we just PostUpdate() for this animation.
+    anim->SetTimeline(this);
+  }
+}
+
+Maybe<ScrollTimeline::ScrollOffsets> ViewTimeline::ComputeOffsets(
+    const nsIScrollableFrame* aScrollFrame,
+    layers::ScrollDirection aOrientation) const {
+  MOZ_ASSERT(mSubject);
+  MOZ_ASSERT(aScrollFrame);
+
+  const Element* subjectElement =
+      AnimationUtils::GetElementForRestyle(mSubject, mSubjectPseudoType);
+  const nsIFrame* subject = subjectElement->GetPrimaryFrame();
+  if (!subject) {
+    // No principal box of the subject, so we cannot compute the offset. This
+    // may happen when we clear all animation collections during unbinding from
+    // the tree.
+    return Nothing();
+  }
+
+  // In order to get the distance between the subject and the scrollport
+  // properly, we use the position based on the domain of the scrolled frame,
+  // instead of the scrollable frame.
+  const nsIFrame* scrolledFrame = aScrollFrame->GetScrolledFrame();
+  MOZ_ASSERT(scrolledFrame);
+  const nsRect subjectRect(subject->GetOffsetTo(scrolledFrame),
+                           subject->GetSize());
+
+  // Use scrollport size (i.e. padding box size - scrollbar size), which is used
+  // for calculating the view progress visibility range.
+  // https://drafts.csswg.org/scroll-animations/#view-progress-visibility-range
+  const nsRect scrollPort = aScrollFrame->GetScrollPortRect();
+
+  // Adjuct the positions and sizes based on the physical axis.
+  nscoord subjectPosition = subjectRect.y;
+  nscoord subjectSize = subjectRect.height;
+  nscoord scrollPortSize = scrollPort.height;
+  if (aOrientation == layers::ScrollDirection::eHorizontal) {
+    // |subjectPosition| should be the position of the start border edge of the
+    // subject, so for R-L case, we have to use XMost() as the start border
+    // edge of the subject, and compute its position by using the x-most side of
+    // the scrolled frame as the origin on the horizontal axis.
+    subjectPosition = scrolledFrame->GetWritingMode().IsPhysicalRTL()
+                          ? scrolledFrame->GetSize().width - subjectRect.XMost()
+                          : subjectRect.x;
+    subjectSize = subjectRect.width;
+    scrollPortSize = scrollPort.width;
+  }
+
+  // |sideInsets.mEnd| is used to adjust the start offset, and
+  // |sideInsets.mStart| is used to adjust the end offset. This is because
+  // |sideInsets.mStart| refers to logical start side [1] of the source box
+  // (i.e. the box of the scrollport), where as |startOffset| refers to the
+  // start of the timeline, and similarly for end side/offset. [1]
+  // https://drafts.csswg.org/css-writing-modes-4/#css-start
+  const auto sideInsets = ComputeInsets(aScrollFrame, aOrientation);
+
+  // Basically, we are computing the "cover" timeline range name, which
+  // represents the full range of the view progress timeline.
+  // https://drafts.csswg.org/scroll-animations-1/#valdef-animation-timeline-range-cover
+
+  // Note: `subjectPosition - scrollPortSize` means the distance between the
+  // start border edge of the subject and the end edge of the scrollport.
+  nscoord startOffset = subjectPosition - scrollPortSize + sideInsets.mEnd;
+  // Note: `subjectPosition + subjectSize` means the position of the end border
+  // edge of the subject. When it touches the start edge of the scrollport, it
+  // is 100%.
+  nscoord endOffset = subjectPosition + subjectSize - sideInsets.mStart;
+  return Some(ScrollOffsets{startOffset, endOffset});
+}
+
+ScrollTimeline::ScrollOffsets ViewTimeline::ComputeInsets(
+    const nsIScrollableFrame* aScrollFrame,
+    layers::ScrollDirection aOrientation) const {
+  // If view-timeline-inset is auto, it indicates to use the value of
+  // scroll-padding. We use logical dimension to map that start/end offset to
+  // the corresponding scroll-padding-{inline|block}-{start|end} values.
+  const WritingMode wm = aScrollFrame->GetScrolledFrame()->GetWritingMode();
+  const auto& scrollPadding =
+      LogicalMargin(wm, aScrollFrame->GetScrollPadding());
+  const bool isBlockAxis =
+      mAxis == StyleScrollAxis::Block ||
+      (mAxis == StyleScrollAxis::Horizontal && wm.IsVertical()) ||
+      (mAxis == StyleScrollAxis::Vertical && !wm.IsVertical());
+
+  // The percentages of view-timelne-inset is relative to the corresponding
+  // dimension of the relevant scrollport.
+  // https://drafts.csswg.org/scroll-animations-1/#view-timeline-inset
+  const nsRect scrollPort = aScrollFrame->GetScrollPortRect();
+  const nscoord percentageBasis =
+      aOrientation == layers::ScrollDirection::eHorizontal ? scrollPort.width
+                                                           : scrollPort.height;
+
+  nscoord startInset =
+      mInset.start.IsAuto()
+          ? (isBlockAxis ? scrollPadding.BStart(wm) : scrollPadding.IStart(wm))
+          : mInset.start.AsLengthPercentage().Resolve(percentageBasis);
+  nscoord endInset =
+      mInset.end.IsAuto()
+          ? (isBlockAxis ? scrollPadding.BEnd(wm) : scrollPadding.IEnd(wm))
+          : mInset.end.AsLengthPercentage().Resolve(percentageBasis);
+  return {startInset, endInset};
+}
+
+}  // namespace mozilla::dom