Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 306 insertions, 0 deletions

diff --git a/dom/animation/ScrollTimeline.cpp b/dom/animation/ScrollTimeline.cpp
new file mode 100644
index 0000000000..27ea7de09a
--- /dev/null
+++ b/dom/animation/ScrollTimeline.cpp
@@ -0,0 +1,306 @@
+/* -*- 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 "ScrollTimeline.h"
+
+#include "mozilla/dom/Animation.h"
+#include "mozilla/dom/ElementInlines.h"
+#include "mozilla/AnimationTarget.h"
+#include "mozilla/DisplayPortUtils.h"
+#include "mozilla/ElementAnimationData.h"
+#include "mozilla/PresShell.h"
+#include "nsIFrame.h"
+#include "nsIScrollableFrame.h"
+#include "nsLayoutUtils.h"
+
+namespace mozilla::dom {
+
+// ---------------------------------
+// Methods of ScrollTimeline
+// ---------------------------------
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(ScrollTimeline)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(ScrollTimeline,
+                                                AnimationTimeline)
+  tmp->Teardown();
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocument)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mSource.mElement)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(ScrollTimeline,
+                                                  AnimationTimeline)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocument)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSource.mElement)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(ScrollTimeline,
+                                               AnimationTimeline)
+
+ScrollTimeline::ScrollTimeline(Document* aDocument, const Scroller& aScroller,
+                               StyleScrollAxis aAxis)
+    : AnimationTimeline(aDocument->GetParentObject(),
+                        aDocument->GetScopeObject()->GetRTPCallerType()),
+      mDocument(aDocument),
+      mSource(aScroller),
+      mAxis(aAxis) {
+  MOZ_ASSERT(aDocument);
+  RegisterWithScrollSource();
+}
+
+/* static */ std::pair<const Element*, PseudoStyleType>
+ScrollTimeline::FindNearestScroller(Element* aSubject,
+                                    PseudoStyleType aPseudoType) {
+  MOZ_ASSERT(aSubject);
+  Element* subject =
+      AnimationUtils::GetElementForRestyle(aSubject, aPseudoType);
+
+  Element* curr = subject->GetFlattenedTreeParentElement();
+  Element* root = subject->OwnerDoc()->GetDocumentElement();
+  while (curr && curr != root) {
+    const ComputedStyle* style = Servo_Element_GetMaybeOutOfDateStyle(curr);
+    MOZ_ASSERT(style, "The ancestor should be styled.");
+    if (style->StyleDisplay()->IsScrollableOverflow()) {
+      break;
+    }
+    curr = curr->GetFlattenedTreeParentElement();
+  }
+  // If there is no scroll container, we use root.
+  if (!curr) {
+    return {root, PseudoStyleType::NotPseudo};
+  }
+  return AnimationUtils::GetElementPseudoPair(curr);
+}
+
+/* static */
+already_AddRefed<ScrollTimeline> ScrollTimeline::MakeAnonymous(
+    Document* aDocument, const NonOwningAnimationTarget& aTarget,
+    StyleScrollAxis aAxis, StyleScroller aScroller) {
+  MOZ_ASSERT(aTarget);
+  Scroller scroller;
+  switch (aScroller) {
+    case StyleScroller::Root:
+      scroller = Scroller::Root(aTarget.mElement->OwnerDoc());
+      break;
+
+    case StyleScroller::Nearest: {
+      auto [element, pseudo] =
+          FindNearestScroller(aTarget.mElement, aTarget.mPseudoType);
+      scroller = Scroller::Nearest(const_cast<Element*>(element), pseudo);
+      break;
+    }
+    case StyleScroller::SelfElement:
+      scroller = Scroller::Self(aTarget.mElement, aTarget.mPseudoType);
+      break;
+  }
+
+  // Each use of scroll() corresponds to its own instance of ScrollTimeline in
+  // the Web Animations API, even if multiple elements use scroll() to refer to
+  // the same scroll container with the same arguments.
+  // https://drafts.csswg.org/scroll-animations-1/#scroll-notation
+  return MakeAndAddRef<ScrollTimeline>(aDocument, scroller, aAxis);
+}
+
+/* static*/ already_AddRefed<ScrollTimeline> ScrollTimeline::MakeNamed(
+    Document* aDocument, Element* aReferenceElement,
+    PseudoStyleType aPseudoType, const StyleScrollTimeline& aStyleTimeline) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  Scroller scroller = Scroller::Named(aReferenceElement, aPseudoType);
+  return MakeAndAddRef<ScrollTimeline>(aDocument, std::move(scroller),
+                                       aStyleTimeline.GetAxis());
+}
+
+Nullable<TimeDuration> ScrollTimeline::GetCurrentTimeAsDuration() const {
+  // If no layout box, this timeline is inactive.
+  if (!mSource || !mSource.mElement->GetPrimaryFrame()) {
+    return nullptr;
+  }
+
+  // if this is not a scroller container, this timeline is inactive.
+  const nsIScrollableFrame* scrollFrame = GetScrollFrame();
+  if (!scrollFrame) {
+    return nullptr;
+  }
+
+  const auto orientation = Axis();
+
+  // If there is no scrollable overflow, then the ScrollTimeline is inactive.
+  // https://drafts.csswg.org/scroll-animations-1/#scrolltimeline-interface
+  if (!scrollFrame->GetAvailableScrollingDirections().contains(orientation)) {
+    return nullptr;
+  }
+
+  const bool isHorizontal = orientation == layers::ScrollDirection::eHorizontal;
+  const nsPoint& scrollPosition = scrollFrame->GetScrollPosition();
+  const Maybe<ScrollOffsets>& offsets =
+      ComputeOffsets(scrollFrame, orientation);
+  if (!offsets) {
+    return nullptr;
+  }
+
+  // Note: For RTL, scrollPosition.x or scrollPosition.y may be negative,
+  // e.g. the range of its value is [0, -range], so we have to use the
+  // absolute value.
+  nscoord position =
+      std::abs(isHorizontal ? scrollPosition.x : scrollPosition.y);
+  double progress = static_cast<double>(position - offsets->mStart) /
+                    static_cast<double>(offsets->mEnd - offsets->mStart);
+  return TimeDuration::FromMilliseconds(progress *
+                                        PROGRESS_TIMELINE_DURATION_MILLISEC);
+}
+
+layers::ScrollDirection ScrollTimeline::Axis() const {
+  MOZ_ASSERT(mSource && mSource.mElement->GetPrimaryFrame());
+
+  const WritingMode wm = mSource.mElement->GetPrimaryFrame()->GetWritingMode();
+  return mAxis == StyleScrollAxis::Horizontal ||
+                 (!wm.IsVertical() && mAxis == StyleScrollAxis::Inline) ||
+                 (wm.IsVertical() && mAxis == StyleScrollAxis::Block)
+             ? layers::ScrollDirection::eHorizontal
+             : layers::ScrollDirection::eVertical;
+}
+
+StyleOverflow ScrollTimeline::SourceScrollStyle() const {
+  MOZ_ASSERT(mSource && mSource.mElement->GetPrimaryFrame());
+
+  const nsIScrollableFrame* scrollFrame = GetScrollFrame();
+  MOZ_ASSERT(scrollFrame);
+
+  const ScrollStyles scrollStyles = scrollFrame->GetScrollStyles();
+
+  return Axis() == layers::ScrollDirection::eHorizontal
+             ? scrollStyles.mHorizontal
+             : scrollStyles.mVertical;
+}
+
+bool ScrollTimeline::APZIsActiveForSource() const {
+  MOZ_ASSERT(mSource);
+  return gfxPlatform::AsyncPanZoomEnabled() &&
+         !nsLayoutUtils::ShouldDisableApzForElement(mSource.mElement) &&
+         DisplayPortUtils::HasNonMinimalNonZeroDisplayPort(mSource.mElement);
+}
+
+bool ScrollTimeline::ScrollingDirectionIsAvailable() const {
+  const nsIScrollableFrame* scrollFrame = GetScrollFrame();
+  MOZ_ASSERT(scrollFrame);
+  return scrollFrame->GetAvailableScrollingDirections().contains(Axis());
+}
+
+void ScrollTimeline::ReplacePropertiesWith(const Element* aReferenceElement,
+                                           PseudoStyleType aPseudoType,
+                                           const StyleScrollTimeline& aNew) {
+  MOZ_ASSERT(aReferenceElement == mSource.mElement &&
+             aPseudoType == mSource.mPseudoType);
+  mAxis = aNew.GetAxis();
+
+  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> ScrollTimeline::ComputeOffsets(
+    const nsIScrollableFrame* aScrollFrame,
+    layers::ScrollDirection aOrientation) const {
+  const nsRect& scrollRange = aScrollFrame->GetScrollRange();
+  nscoord range = aOrientation == layers::ScrollDirection::eHorizontal
+                      ? scrollRange.width
+                      : scrollRange.height;
+  MOZ_ASSERT(range > 0);
+  return Some(ScrollOffsets{0, range});
+}
+
+void ScrollTimeline::RegisterWithScrollSource() {
+  if (!mSource) {
+    return;
+  }
+
+  auto& scheduler =
+      ProgressTimelineScheduler::Ensure(mSource.mElement, mSource.mPseudoType);
+  scheduler.AddTimeline(this);
+}
+
+void ScrollTimeline::UnregisterFromScrollSource() {
+  if (!mSource) {
+    return;
+  }
+
+  auto* scheduler =
+      ProgressTimelineScheduler::Get(mSource.mElement, mSource.mPseudoType);
+  if (!scheduler) {
+    return;
+  }
+
+  scheduler->RemoveTimeline(this);
+  if (scheduler->IsEmpty()) {
+    ProgressTimelineScheduler::Destroy(mSource.mElement, mSource.mPseudoType);
+  }
+}
+
+const nsIScrollableFrame* ScrollTimeline::GetScrollFrame() const {
+  if (!mSource) {
+    return nullptr;
+  }
+
+  switch (mSource.mType) {
+    case Scroller::Type::Root:
+      if (const PresShell* presShell =
+              mSource.mElement->OwnerDoc()->GetPresShell()) {
+        return presShell->GetRootScrollFrameAsScrollable();
+      }
+      return nullptr;
+    case Scroller::Type::Nearest:
+    case Scroller::Type::Name:
+    case Scroller::Type::Self:
+      return nsLayoutUtils::FindScrollableFrameFor(mSource.mElement);
+  }
+
+  MOZ_ASSERT_UNREACHABLE("Unsupported scroller type");
+  return nullptr;
+}
+
+void ScrollTimeline::NotifyAnimationContentVisibilityChanged(
+    Animation* aAnimation, bool aIsVisible) {
+  AnimationTimeline::NotifyAnimationContentVisibilityChanged(aAnimation,
+                                                             aIsVisible);
+  if (mAnimationOrder.isEmpty()) {
+    UnregisterFromScrollSource();
+  } else {
+    RegisterWithScrollSource();
+  }
+}
+
+// ------------------------------------
+// Methods of ProgressTimelineScheduler
+// ------------------------------------
+/* static */ ProgressTimelineScheduler* ProgressTimelineScheduler::Get(
+    const Element* aElement, PseudoStyleType aPseudoType) {
+  MOZ_ASSERT(aElement);
+  auto* data = aElement->GetAnimationData();
+  if (!data) {
+    return nullptr;
+  }
+
+  return data->GetProgressTimelineScheduler(aPseudoType);
+}
+
+/* static */ ProgressTimelineScheduler& ProgressTimelineScheduler::Ensure(
+    Element* aElement, PseudoStyleType aPseudoType) {
+  MOZ_ASSERT(aElement);
+  return aElement->EnsureAnimationData().EnsureProgressTimelineScheduler(
+      *aElement, aPseudoType);
+}
+
+/* static */
+void ProgressTimelineScheduler::Destroy(const Element* aElement,
+                                        PseudoStyleType aPseudoType) {
+  auto* data = aElement->GetAnimationData();
+  MOZ_ASSERT(data);
+  data->ClearProgressTimelineScheduler(aPseudoType);
+}
+
+}  // namespace mozilla::dom