Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

1 files changed, 281 insertions, 0 deletions

diff --git a/dom/animation/ScrollTimeline.h b/dom/animation/ScrollTimeline.h
new file mode 100644
index 0000000000..129872f61b
--- /dev/null
+++ b/dom/animation/ScrollTimeline.h
@@ -0,0 +1,281 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ScrollTimeline_h
+#define mozilla_dom_ScrollTimeline_h
+
+#include "mozilla/dom/AnimationTimeline.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/HashTable.h"
+#include "mozilla/PairHash.h"
+#include "mozilla/ServoStyleConsts.h"
+#include "mozilla/WritingModes.h"
+
+#define PROGRESS_TIMELINE_DURATION_MILLISEC 100000
+
+class nsIScrollableFrame;
+
+namespace mozilla {
+class ElementAnimationData;
+struct NonOwningAnimationTarget;
+namespace dom {
+class Element;
+
+/**
+ * Implementation notes
+ * --------------------
+ *
+ * ScrollTimelines do not observe refreshes the way DocumentTimelines do.
+ * This is because the refresh driver keeps ticking while it has registered
+ * refresh observers. For a DocumentTimeline, it's appropriate to keep the
+ * refresh driver ticking as long as there are active animations, since the
+ * animations need to be sampled on every frame. Scroll-linked animations,
+ * however, only need to be sampled when scrolling has occurred, so keeping
+ * the refresh driver ticking is wasteful.
+ *
+ * As a result, we schedule an animation restyle when
+ * 1) there are any scroll offsets updated (from APZ or script), via
+ *    nsIScrollableFrame, or
+ * 2) there are any possible scroll range updated during the frame reflow.
+ *
+ * -------------
+ * | Animation |
+ * -------------
+ *   ^
+ *   | Call Animation::Tick() if there are any scroll updates.
+ *   |
+ * ------------------
+ * | ScrollTimeline |
+ * ------------------
+ *   ^
+ *   | Try schedule the scroll-driven animations, if there are any scroll
+ *   | offsets changed or the scroll range changed [1].
+ *   |
+ * ----------------------
+ * | nsIScrollableFrame |
+ * ----------------------
+ *
+ * [1] nsIScrollableFrame uses its associated dom::Element to lookup the
+ *     ScrollTimelineSet, and iterates the set to schedule the animations
+ *     linked to the ScrollTimelines.
+ */
+class ScrollTimeline : public AnimationTimeline {
+  template <typename T, typename... Args>
+  friend already_AddRefed<T> mozilla::MakeAndAddRef(Args&&... aArgs);
+
+ public:
+  struct Scroller {
+    // FIXME: Bug 1765211. Perhaps we only need root and a specific element.
+    // This depends on how we fix this bug.
+    enum class Type : uint8_t {
+      Root,
+      Nearest,
+      Name,
+      Self,
+    };
+    Type mType = Type::Root;
+    RefPtr<Element> mElement;
+    PseudoStyleType mPseudoType;
+
+    // We use the owner doc of the animation target. This may be different from
+    // |mDocument| after we implement ScrollTimeline interface for script.
+    static Scroller Root(const Document* aOwnerDoc) {
+      // For auto, we use scrolling element as the default scroller.
+      // However, it's mutable, and we would like to keep things simple, so
+      // we always register the ScrollTimeline to the document element (i.e.
+      // root element) because the content of the root scroll frame is the root
+      // element.
+      return {Type::Root, aOwnerDoc->GetDocumentElement(),
+              PseudoStyleType::NotPseudo};
+    }
+
+    static Scroller Nearest(Element* aElement, PseudoStyleType aPseudoType) {
+      return {Type::Nearest, aElement, aPseudoType};
+    }
+
+    static Scroller Named(Element* aElement, PseudoStyleType aPseudoType) {
+      return {Type::Name, aElement, aPseudoType};
+    }
+
+    static Scroller Self(Element* aElement, PseudoStyleType aPseudoType) {
+      return {Type::Self, aElement, aPseudoType};
+    }
+
+    explicit operator bool() const { return mElement; }
+    bool operator==(const Scroller& aOther) const {
+      return mType == aOther.mType && mElement == aOther.mElement &&
+             mPseudoType == aOther.mPseudoType;
+    }
+  };
+
+  static already_AddRefed<ScrollTimeline> MakeAnonymous(
+      Document* aDocument, const NonOwningAnimationTarget& aTarget,
+      StyleScrollAxis aAxis, StyleScroller aScroller);
+
+  // Note: |aReferfenceElement| is used as the scroller which specifies
+  // scroll-timeline-name property.
+  static already_AddRefed<ScrollTimeline> MakeNamed(
+      Document* aDocument, Element* aReferenceElement,
+      PseudoStyleType aPseudoType, const StyleScrollTimeline& aStyleTimeline);
+
+  bool operator==(const ScrollTimeline& aOther) const {
+    return mDocument == aOther.mDocument && mSource == aOther.mSource &&
+           mAxis == aOther.mAxis;
+  }
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ScrollTimeline, AnimationTimeline)
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override {
+    // FIXME: Bug 1676794: Implement ScrollTimeline interface.
+    return nullptr;
+  }
+
+  // AnimationTimeline methods.
+  Nullable<TimeDuration> GetCurrentTimeAsDuration() const override;
+  bool TracksWallclockTime() const override { return false; }
+  Nullable<TimeDuration> ToTimelineTime(
+      const TimeStamp& aTimeStamp) const override {
+    // It's unclear to us what should we do for this function now, so return
+    // nullptr.
+    return nullptr;
+  }
+  TimeStamp ToTimeStamp(const TimeDuration& aTimelineTime) const override {
+    // It's unclear to us what should we do for this function now, so return
+    // zero time.
+    return {};
+  }
+  Document* GetDocument() const override { return mDocument; }
+  bool IsMonotonicallyIncreasing() const override { return false; }
+  bool IsScrollTimeline() const override { return true; }
+  const ScrollTimeline* AsScrollTimeline() const override { return this; }
+  bool IsViewTimeline() const override { return false; }
+
+  Nullable<TimeDuration> TimelineDuration() const override {
+    // We are using this magic number for progress-based timeline duration
+    // because we don't support percentage for duration.
+    return TimeDuration::FromMilliseconds(PROGRESS_TIMELINE_DURATION_MILLISEC);
+  }
+
+  void ScheduleAnimations() {
+    // FIXME: Bug 1737927: Need to check the animation mutation observers for
+    // animations with scroll timelines.
+    // nsAutoAnimationMutationBatch mb(mDocument);
+
+    Tick();
+  }
+
+  // If the source of a ScrollTimeline is an element whose principal box does
+  // not exist or is not a scroll container, then its phase is the timeline
+  // inactive phase. It is otherwise in the active phase. This returns true if
+  // the timeline is in active phase.
+  // https://drafts.csswg.org/web-animations-1/#inactive-timeline
+  // Note: This function is called only for compositor animations, so we must
+  // have the primary frame (principal box) for the source element if it exists.
+  bool IsActive() const { return GetScrollFrame(); }
+
+  Element* SourceElement() const {
+    MOZ_ASSERT(mSource);
+    return mSource.mElement;
+  }
+
+  // A helper to get the physical orientation of this scroll-timeline.
+  layers::ScrollDirection Axis() const;
+
+  StyleOverflow SourceScrollStyle() const;
+
+  bool APZIsActiveForSource() const;
+
+  bool ScrollingDirectionIsAvailable() const;
+
+  void ReplacePropertiesWith(const Element* aReferenceElement,
+                             PseudoStyleType aPseudoType,
+                             const StyleScrollTimeline& aNew);
+
+ protected:
+  virtual ~ScrollTimeline() { Teardown(); }
+  ScrollTimeline() = delete;
+  ScrollTimeline(Document* aDocument, const Scroller& aScroller,
+                 StyleScrollAxis aAxis);
+
+  struct ScrollOffsets {
+    nscoord mStart = 0;
+    nscoord mEnd = 0;
+  };
+  virtual Maybe<ScrollOffsets> ComputeOffsets(
+      const nsIScrollableFrame* aScrollFrame,
+      layers::ScrollDirection aOrientation) const;
+
+  // Note: This function is required to be idempotent, as it can be called from
+  // both cycleCollection::Unlink() and ~ScrollTimeline(). When modifying this
+  // function, be sure to preserve this property.
+  void Teardown() { UnregisterFromScrollSource(); }
+
+  // Register this scroll timeline to the element property.
+  void RegisterWithScrollSource();
+
+  // Unregister this scroll timeline from the element property.
+  void UnregisterFromScrollSource();
+
+  const nsIScrollableFrame* GetScrollFrame() const;
+
+  static std::pair<const Element*, PseudoStyleType> FindNearestScroller(
+      Element* aSubject, PseudoStyleType aPseudoType);
+
+  RefPtr<Document> mDocument;
+
+  // FIXME: Bug 1765211: We may have to update the source element once the
+  // overflow property of the scroll-container is updated when we are using
+  // nearest scroller.
+  Scroller mSource;
+  StyleScrollAxis mAxis;
+};
+
+/**
+ * A wrapper around a hashset of ScrollTimeline objects to handle the scheduling
+ * of scroll driven animations. This is used for all kinds of progress
+ * timelines, i.e. anonymous/named scroll timelines and anonymous/named view
+ * timelines. And this object is owned by the scroll source (See
+ * ElementAnimationData and nsGfxScrollFrame for the usage).
+ */
+class ProgressTimelineScheduler {
+ public:
+  ProgressTimelineScheduler() { MOZ_COUNT_CTOR(ProgressTimelineScheduler); }
+  ~ProgressTimelineScheduler() { MOZ_COUNT_DTOR(ProgressTimelineScheduler); }
+
+  static ProgressTimelineScheduler* Get(const Element* aElement,
+                                        PseudoStyleType aPseudoType);
+  static ProgressTimelineScheduler& Ensure(Element* aElement,
+                                           PseudoStyleType aPseudoType);
+  static void Destroy(const Element* aElement, PseudoStyleType aPseudoType);
+
+  void AddTimeline(ScrollTimeline* aScrollTimeline) {
+    Unused << mTimelines.put(aScrollTimeline);
+  }
+  void RemoveTimeline(ScrollTimeline* aScrollTimeline) {
+    mTimelines.remove(aScrollTimeline);
+  }
+
+  bool IsEmpty() const { return mTimelines.empty(); }
+
+  void ScheduleAnimations() const {
+    for (auto iter = mTimelines.iter(); !iter.done(); iter.next()) {
+      iter.get()->ScheduleAnimations();
+    }
+  }
+
+ private:
+  // We let Animations own its scroll timeline or view timeline if it is
+  // anonymous. For named progress timelines, they are created and destroyed by
+  // TimelineCollection.
+  HashSet<ScrollTimeline*> mTimelines;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_ScrollTimeline_h