/* 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 "ViewTransition.h"

#include "AnchorPositioningUtils.h"
#include "Units.h"
#include "WindowRenderer.h"
#include "mozilla/AnimationEventDispatcher.h"
#include "mozilla/EffectSet.h"
#include "mozilla/ElementAnimationData.h"
#include "mozilla/FlowMarkers.h"
#include "mozilla/SVGIntegrationUtils.h"
#include "mozilla/ServoStyleConsts.h"
#include "mozilla/WritingModes.h"
#include "mozilla/dom/BindContext.h"
#include "mozilla/dom/DocumentInlines.h"
#include "mozilla/dom/DocumentTimeline.h"
#include "mozilla/dom/Promise-inl.h"
#include "mozilla/dom/ViewTransitionBinding.h"
#include "mozilla/dom/ViewTransitionTypeSet.h"
#include "mozilla/image/WebRenderImageProvider.h"
#include "mozilla/layers/RenderRootStateManager.h"
#include "mozilla/layers/WebRenderBridgeChild.h"
#include "mozilla/layers/WebRenderLayerManager.h"
#include "mozilla/webrender/WebRenderAPI.h"
#include "nsCanvasFrame.h"
#include "nsDisplayList.h"
#include "nsFrameState.h"
#include "nsITimer.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
#include "nsString.h"

namespace mozilla::dom {

LazyLogModule gViewTransitionsLog("ViewTransitions");

NS_DECLARE_FRAME_PROPERTY_RELEASABLE(ViewTransitionCaptureName, nsAtom)

static void SetCaptured(nsIFrame* aFrame, bool aCaptured,
                        nsAtom* aNameIfCaptured) {
  aFrame->AddOrRemoveStateBits(NS_FRAME_CAPTURED_IN_VIEW_TRANSITION, aCaptured);
  if (aCaptured) {
    aFrame->AddProperty(ViewTransitionCaptureName(),
                        do_AddRef(aNameIfCaptured).take());
  } else {
    aFrame->RemoveProperty(ViewTransitionCaptureName());
  }
  aFrame->InvalidateFrameSubtree();
  if (aFrame->Style()->IsRootElementStyle()) {
    aFrame->PresShell()->GetRootFrame()->InvalidateFrameSubtree();
  }
}

// Set capture's old transform to a <transform-function> that would map
// element's border box from the snapshot containing block origin to its
// current visual position.
//
// Since we're using viewport as the snapshot origin, we can use
// GetBoundingClientRect() effectively...
//
// TODO(emilio): This might need revision.
static CSSToCSSMatrix4x4Flagged EffectiveTransform(nsIFrame* aFrame) {
  if (aFrame->GetSize().IsEmpty() || aFrame->Style()->IsRootElementStyle()) {
    return {};
  }

  auto matrix = CSSToCSSMatrix4x4Flagged::FromUnknownMatrix(
      nsLayoutUtils::GetTransformToAncestor(
          RelativeTo{aFrame},
          RelativeTo{nsLayoutUtils::GetContainingBlockForClientRect(aFrame)},
          nsIFrame::IN_CSS_UNITS, nullptr));

  // Compensate for the default transform-origin of 50% 50% using border box
  // dimensions.
  auto borderBoxRect = CSSRect::FromAppUnits(aFrame->GetRect());
  matrix.ChangeBasis(-borderBoxRect.Width() / 2, -borderBoxRect.Height() / 2,
                     0.0f);
  return matrix;
}

enum class CapturedRectType { BorderBox, InkOverflowBox };

static inline nsRect SnapRect(const nsRect& aRect, nscoord aAppUnitsPerPixel) {
  return LayoutDeviceIntRect::ToAppUnits(
      LayoutDeviceIntRect::FromUnknownRect(
          aRect.ToOutsidePixels(aAppUnitsPerPixel)),
      aAppUnitsPerPixel);
}

static inline nsRect CapturedRect(const nsIFrame* aFrame,
                                  const nsSize& aSnapshotContainingBlockSize,
                                  CapturedRectType aType) {
  if (aFrame->Style()->IsRootElementStyle()) {
    return nsRect(nsPoint(), aSnapshotContainingBlockSize);
  }

  if (aType == CapturedRectType::BorderBox) {
    return aFrame->GetRectRelativeToSelf();
  }

  return SnapRect(aFrame->InkOverflowRectRelativeToSelf(),
                  aFrame->PresContext()->AppUnitsPerDevPixel());
}

static StyleViewTransitionClass DocumentScopedClassListFor(
    const nsIFrame* aFrame) {
  const auto& classInfo = aFrame->StyleUIReset()->mViewTransitionClass;
  nsIContent* content = aFrame->GetContent();
  if (!content || AnchorPositioningUtils::GetShadowRootForTreeScope(
                      *content->AsElement(), classInfo.scope)) {
    return StyleViewTransitionClass();
  }

  return classInfo;
}

static constexpr wr::ImageKey kNoKey{{0}, 0};
struct OldSnapshotData {
  wr::ImageKey mImageKey = kNoKey;
  // Snapshot size should match the captured element’s InkOverflowBox size,
  // snapped.
  nsRect mSnapshotRect;
  RefPtr<layers::RenderRootStateManager> mManager;
  bool mUsed = false;

  OldSnapshotData() = default;

  explicit OldSnapshotData(nsIFrame* aFrame,
                           const nsSize& aSnapshotContainingBlockSize)
      : mSnapshotRect(CapturedRect(aFrame, aSnapshotContainingBlockSize,
                                   CapturedRectType::InkOverflowBox)) {}

  void EnsureKey(layers::RenderRootStateManager* aManager,
                 wr::IpcResourceUpdateQueue& aResources) {
    if (mImageKey != kNoKey) {
      MOZ_ASSERT(mManager == aManager, "Stale manager?");
      return;
    }
    mManager = aManager;
    mImageKey = aManager->WrBridge()->GetNextImageKey();
    aResources.AddSnapshotImage(wr::SnapshotImageKey{mImageKey});
  }

  ~OldSnapshotData() {
    if (mManager) {
      wr::SnapshotImageKey key = {mImageKey};
      if (mUsed) {
        mManager->AddSnapshotImageKeyForDiscard(key);
      } else {
        mManager->AddUnusedSnapshotImageKeyForDiscard(key);
      }
    }
  }
};

struct CapturedElementOldState {
  OldSnapshotData mSnapshot;
  // Whether we tried to capture an image. Note we might fail to get a
  // snapshot, so this might not be the same as !!mImage.
  bool mTriedImage = false;

  nsSize mBorderBoxSize;
  CSSToCSSMatrix4x4Flagged mTransform;
  StyleWritingModeProperty mWritingMode =
      StyleWritingModeProperty::HorizontalTb;
  StyleDirection mDirection = StyleDirection::Ltr;
  StyleTextOrientation mTextOrientation = StyleTextOrientation::Mixed;
  StyleBlend mMixBlendMode = StyleBlend::Normal;
  StyleOwnedSlice<StyleFilter> mBackdropFilters;
  // Note: it's unfortunate we cannot just store the bits here. color-scheme
  // property uses idents for serialization. If the idents and bits are not
  // aligned, we assert it in ToCSS.
  StyleColorScheme mColorScheme;

  CapturedElementOldState(nsIFrame* aFrame,
                          const nsSize& aSnapshotContainingBlockSize)
      : mSnapshot(aFrame, aSnapshotContainingBlockSize),
        mTriedImage(true),
        mBorderBoxSize(CapturedRect(aFrame, aSnapshotContainingBlockSize,
                                    CapturedRectType::BorderBox)
                           .Size()),
        mTransform(EffectiveTransform(aFrame)),
        mWritingMode(aFrame->StyleVisibility()->mWritingMode),
        mDirection(aFrame->StyleVisibility()->mDirection),
        mTextOrientation(aFrame->StyleVisibility()->mTextOrientation),
        mMixBlendMode(aFrame->StyleEffects()->mMixBlendMode),
        mBackdropFilters(aFrame->StyleEffects()->mBackdropFilters),
        mColorScheme(aFrame->StyleUI()->mColorScheme) {}

  CapturedElementOldState() = default;
};

// https://drafts.csswg.org/css-view-transitions/#captured-element
struct ViewTransitionCapturedElement {
  CapturedElementOldState mOldState;
  RefPtr<Element> mNewElement;
  wr::SnapshotImageKey mNewSnapshotKey{kNoKey};
  // Snapshot size + offset, should match the captured element’s InkOverflowBox
  // size, snapped.
  nsRect mNewSnapshotRect;
  nsSize mNewBorderBoxSize;

  ViewTransitionCapturedElement() = default;

  ViewTransitionCapturedElement(nsIFrame* aFrame,
                                const nsSize& aSnapshotContainingBlockSize,
                                StyleViewTransitionClass&& aClassList)
      : mOldState(aFrame, aSnapshotContainingBlockSize),
        mClassList(std::move(aClassList)) {}

  // https://drafts.csswg.org/css-view-transitions-1/#captured-element-style-definitions
  nsTArray<Keyframe> mGroupKeyframes;
  // The group animation-name rule and group styles rule, merged into one.
  RefPtr<StyleLockedDeclarationBlock> mGroupRule;
  // The image pair isolation rule.
  RefPtr<StyleLockedDeclarationBlock> mImagePairRule;
  // The rules for ::view-transition-old(<name>).
  RefPtr<StyleLockedDeclarationBlock> mOldRule;
  // The rules for ::view-transition-new(<name>).
  RefPtr<StyleLockedDeclarationBlock> mNewRule;

  // The view-transition-class associated with this captured element.
  // https://drafts.csswg.org/css-view-transitions-2/#captured-element-class-list
  StyleViewTransitionClass mClassList;

  // If snapshots are very large, compute active rects to restrict their
  // bounds, based on what's most likely visible during the transition.
  Maybe<nsRect> mOldActiveRect;
  Maybe<nsRect> mNewActiveRect;

  void CaptureClassList(StyleViewTransitionClass&& aClassList) {
    mClassList = std::move(aClassList);
  }

  ~ViewTransitionCapturedElement() {
    if (wr::AsImageKey(mNewSnapshotKey) != kNoKey) {
      MOZ_ASSERT(mOldState.mSnapshot.mManager);
      mOldState.mSnapshot.mManager->AddSnapshotImageKeyForDiscard(
          mNewSnapshotKey);
    }
  }
};

// This definition should not be in the header as ViewTransitionCapturedElement
// would be incomplete with non-trivial destructor.
ViewTransitionParams::~ViewTransitionParams() = default;

static inline void ImplCycleCollectionTraverse(
    nsCycleCollectionTraversalCallback& aCb,
    const ViewTransitionCapturedElement& aField, const char* aName,
    uint32_t aFlags = 0) {
  ImplCycleCollectionTraverse(aCb, aField.mNewElement, aName, aFlags);
}

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ViewTransition, mDocument,
                                      mUpdateCallback,
                                      mUpdateCallbackDonePromise, mReadyPromise,
                                      mFinishedPromise, mNamedElements, mTypes,
                                      mSnapshotContainingBlock)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ViewTransition)
  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END

NS_IMPL_CYCLE_COLLECTING_ADDREF(ViewTransition)
NS_IMPL_CYCLE_COLLECTING_RELEASE(ViewTransition)

ViewTransition::ViewTransition(Document& aDoc,
                               ViewTransitionUpdateCallback* aCb,
                               TypeList&& aTypeList)
    : mDocument(&aDoc), mUpdateCallback(aCb), mTypeList(std::move(aTypeList)) {}

ViewTransition::~ViewTransition() { ClearTimeoutTimer(); }

/* static */
already_AddRefed<ViewTransition> ViewTransition::CreateCrossDocument(
    Document& aDocument, UniquePtr<ViewTransitionParams> aInboundParams,
    TypeList&& aResolvedRule) {
  // https://drafts.csswg.org/css-view-transitions-2/#resolve-inbound-cross-document-view-transition

  // Step 10. Create a new ViewTransition whose named elements and
  // initial snapshot containing block size are initialized from inbound params.
  // Step 14. Set active types to resolvedRule.
  MOZ_ASSERT(aInboundParams);
  RefPtr<ViewTransition> vt =
      new ViewTransition(aDocument, nullptr, std::move(aResolvedRule));
  vt->mNamedElements = std::move(aInboundParams->namedElements);
  vt->mNames = std::move(aInboundParams->names);
  vt->mInitialSnapshotContainingBlockSize =
      aInboundParams->initialSnapshotContainingBlockSize;

  // Step 12. Resolve updateCallbackDone with undefined.
  vt->mUpdateCallbackDonePromise->MaybeResolveWithUndefined();

  // Step 13. Set phase to update-callback-called.
  vt->mPhase = Phase::UpdateCallbackCalled;

  return vt.forget();
}

Element* ViewTransition::GetViewTransitionTreeRoot() const {
  return mSnapshotContainingBlock
             ? mSnapshotContainingBlock->GetFirstElementChild()
             : nullptr;
}

void ViewTransition::GetCapturedFrames(
    nsTArray<nsIFrame*>& aCapturedFrames) const {
  if (mOldCaptureElements) {
    for (const auto& [f, _] : *mOldCaptureElements) {
      aCapturedFrames.AppendElement(f);
    }
  }

  for (const auto& entry : mNamedElements) {
    CapturedElement& capturedElement = *entry.GetData();
    if (capturedElement.mNewElement &&
        capturedElement.mNewElement->GetPrimaryFrame()) {
      aCapturedFrames.AppendElement(
          capturedElement.mNewElement->GetPrimaryFrame());
    }
  }
}

Maybe<nsRect> ViewTransition::GetOldInkOverflowRect(nsAtom* aName) const {
  auto* el = mNamedElements.Get(aName);
  if (NS_WARN_IF(!el)) {
    return {};
  }
  return Some(el->mOldState.mSnapshot.mSnapshotRect);
}

Maybe<nsRect> ViewTransition::GetNewInkOverflowRect(nsAtom* aName) const {
  auto* el = mNamedElements.Get(aName);
  if (NS_WARN_IF(!el)) {
    return {};
  }
  return Some(el->mNewSnapshotRect);
}

Maybe<nsSize> ViewTransition::GetOldBorderBoxSize(nsAtom* aName) const {
  auto* el = mNamedElements.Get(aName);
  if (NS_WARN_IF(!el)) {
    return {};
  }
  return Some(el->mOldState.mBorderBoxSize);
}

Maybe<nsSize> ViewTransition::GetNewBorderBoxSize(nsAtom* aName) const {
  auto* el = mNamedElements.Get(aName);
  if (NS_WARN_IF(!el)) {
    return {};
  }
  return Some(el->mNewBorderBoxSize);
}

const wr::ImageKey* ViewTransition::GetOrCreateOldImageKey(
    nsAtom* aName, layers::RenderRootStateManager* aManager,
    wr::IpcResourceUpdateQueue& aResources) const {
  auto* el = mNamedElements.Get(aName);
  if (NS_WARN_IF(!el)) {
    return nullptr;
  }
  el->mOldState.mSnapshot.EnsureKey(aManager, aResources);
  return &el->mOldState.mSnapshot.mImageKey;
}

const wr::ImageKey* ViewTransition::ReadOldImageKey(
    nsAtom* aName, layers::RenderRootStateManager* aManager,
    wr::IpcResourceUpdateQueue& aResources) const {
  auto* el = mNamedElements.Get(aName);
  if (NS_WARN_IF(!el)) {
    return nullptr;
  }

  el->mOldState.mSnapshot.mUsed = true;
  return &el->mOldState.mSnapshot.mImageKey;
}

const wr::ImageKey* ViewTransition::GetNewImageKey(nsAtom* aName) const {
  auto* el = mNamedElements.Get(aName);
  if (NS_WARN_IF(!el)) {
    return nullptr;
  }
  return &el->mNewSnapshotKey._0;
}

const wr::ImageKey* ViewTransition::GetImageKeyForCapturedFrame(
    nsIFrame* aFrame, layers::RenderRootStateManager* aManager,
    wr::IpcResourceUpdateQueue& aResources) const {
  MOZ_ASSERT(aFrame);
  MOZ_ASSERT(aFrame->HasAnyStateBits(NS_FRAME_CAPTURED_IN_VIEW_TRANSITION));

  nsAtom* name = aFrame->GetProperty(ViewTransitionCaptureName());
  if (NS_WARN_IF(!name)) {
    return nullptr;
  }
  const bool isOld = mPhase < Phase::Animating;

  VT_LOG("ViewTransition::GetImageKeyForCapturedFrame(%s, old=%d)\n",
         nsAtomCString(name).get(), isOld);

  if (isOld) {
    const auto* key = GetOrCreateOldImageKey(name, aManager, aResources);
    VT_LOG(" > old image is %s", key ? ToString(*key).c_str() : "null");
    return key;
  }
  auto* el = mNamedElements.Get(name);
  if (NS_WARN_IF(!el)) {
    return nullptr;
  }
  if (NS_WARN_IF(el->mNewElement != aFrame->GetContent())) {
    return nullptr;
  }
  if (wr::AsImageKey(el->mNewSnapshotKey) == kNoKey) {
    MOZ_ASSERT(!el->mOldState.mSnapshot.mManager ||
                   el->mOldState.mSnapshot.mManager == aManager,
               "Stale manager?");
    el->mNewSnapshotKey = {aManager->WrBridge()->GetNextImageKey()};
    el->mOldState.mSnapshot.mManager = aManager;
    aResources.AddSnapshotImage(el->mNewSnapshotKey);
  }
  VT_LOG(" > new image is %s", ToString(el->mNewSnapshotKey._0).c_str());
  return &el->mNewSnapshotKey._0;
}

nsIGlobalObject* ViewTransition::GetParentObject() const {
  return mDocument ? mDocument->GetParentObject() : nullptr;
}

Promise* ViewTransition::GetUpdateCallbackDone(ErrorResult& aRv) {
  if (!mUpdateCallbackDonePromise) {
    mUpdateCallbackDonePromise = Promise::Create(GetParentObject(), aRv);
  }
  return mUpdateCallbackDonePromise;
}

Promise* ViewTransition::GetReady(ErrorResult& aRv) {
  if (!mReadyPromise) {
    mReadyPromise = Promise::Create(GetParentObject(), aRv);
  }
  return mReadyPromise;
}

Promise* ViewTransition::GetFinished(ErrorResult& aRv) {
  if (!mFinishedPromise) {
    mFinishedPromise = Promise::Create(GetParentObject(), aRv);
  }
  return mFinishedPromise;
}

// This performs the step 5 in setup view transition.
// https://drafts.csswg.org/css-view-transitions-1/#setup-view-transition
void ViewTransition::MaybeScheduleUpdateCallback() {
  AUTO_PROFILER_FLOW_MARKER("ViewTransition::MaybeScheduleUpdateCallback",
                            LAYOUT, Flow::FromPointer(this));
  // 1. If transition’s phase is "done", then abort these steps.
  // Note: This happens if transition was skipped before this point.
  if (mPhase == Phase::Done) {
    return;
  }

  RefPtr doc = mDocument;

  // 2. Schedule the update callback for transition.
  doc->ScheduleViewTransitionUpdateCallback(this);

  // 3. Flush the update callback queue.
  doc->FlushViewTransitionUpdateCallbackQueue();
}

// https://drafts.csswg.org/css-view-transitions-1/#call-the-update-callback
void ViewTransition::CallUpdateCallback(ErrorResult& aRv) {
  MOZ_ASSERT(mDocument);
  // Step 1:  Assert: transition's phase is "done", or before
  // "update-callback-called".
  MOZ_ASSERT(mPhase == Phase::Done ||
             UnderlyingValue(mPhase) <
                 UnderlyingValue(Phase::UpdateCallbackCalled));
  VT_LOG("ViewTransition::CallUpdateCallback(%d)\n", int(mPhase));
  AUTO_PROFILER_FLOW_MARKER("ViewTransition::CallUpdateCallback", LAYOUT,
                            Flow::FromPointer(this));

  // Step 5: If transition's phase is not "done", then set transition's phase
  // to "update-callback-called".
  //
  // NOTE(emilio): This is swapped with the spec because the spec is broken,
  // see https://github.com/w3c/csswg-drafts/issues/10822
  if (mPhase != Phase::Done) {
    mPhase = Phase::UpdateCallbackCalled;
  }

  // Step 2: Let callbackPromise be null.
  RefPtr<Promise> callbackPromise;
  if (!mUpdateCallback) {
    // Step 3: If transition's update callback is null, then set callbackPromise
    // to a promise resolved with undefined, in transition’s relevant Realm.
    callbackPromise =
        Promise::CreateResolvedWithUndefined(GetParentObject(), aRv);
  } else {
    // Step 4: Otherwise set callbackPromise to the result of invoking
    // transition’s update callback. MOZ_KnownLive because the callback can only
    // go away when we get CCd.
    callbackPromise = MOZ_KnownLive(mUpdateCallback)->Call(aRv);
  }
  if (aRv.Failed()) {
    // TODO(emilio): Do we need extra error handling here?
    return;
  }
  MOZ_ASSERT(callbackPromise);
  // Step 8: React to callbackPromise with fulfillSteps and rejectSteps.
  callbackPromise->AddCallbacksWithCycleCollectedArgs(
      [](JSContext*, JS::Handle<JS::Value>, ErrorResult& aRv,
         ViewTransition* aVt) {
        AUTO_PROFILER_FLOW_MARKER("ViewTransition::UpdateCallbackResolve",
                                  LAYOUT, Flow::FromPointer(aVt));
        // We clear the timeout when we are ready to activate. Otherwise, any
        // animations with the duration longer than
        // StaticPrefs::dom_viewTransitions_timeout_ms() will be interrupted.
        // FIXME: We may need a better solution to tweak the timeout, e.g. reset
        // the timeout to a longer value or so on.
        aVt->ClearTimeoutTimer();

        // Step 6: Let fulfillSteps be to following steps:
        if (Promise* ucd = aVt->GetUpdateCallbackDone(aRv)) {
          // 6.1: Resolve transition's update callback done promise with
          // undefined.
          ucd->MaybeResolveWithUndefined();
        }
        // Unlike other timings, this is not guaranteed to happen with clean
        // layout, and Activate() needs to look at the frame tree to capture the
        // new state, so we need to flush frames. Do it here so that we deal
        // with other potential script execution skipping the transition or
        // what not in a consistent way.
        aVt->mDocument->FlushPendingNotifications(FlushType::Layout);
        if (aVt->mPhase == Phase::Done) {
          // "Skip a transition" step 8. We need to resolve "finished" after
          // update-callback-done.
          if (Promise* finished = aVt->GetFinished(aRv)) {
            finished->MaybeResolveWithUndefined();
          }
        }
        aVt->Activate();
      },
      [](JSContext*, JS::Handle<JS::Value> aReason, ErrorResult& aRv,
         ViewTransition* aVt) {
        AUTO_PROFILER_FLOW_MARKER("ViewTransition::UpdateCallbackReject",
                                  LAYOUT, Flow::FromPointer(aVt));
        // Clear the timeout because we are ready to skip the view transitions.
        aVt->ClearTimeoutTimer();

        // Step 7: Let rejectSteps be to following steps:
        if (Promise* ucd = aVt->GetUpdateCallbackDone(aRv)) {
          // 7.1: Reject transition's update callback done promise with reason.
          ucd->MaybeReject(aReason);
        }

        // 7.2: If transition's phase is "done", then return.
        if (aVt->mPhase == Phase::Done) {
          // "Skip a transition" step 8. We need to resolve "finished" after
          // update-callback-done.
          if (Promise* finished = aVt->GetFinished(aRv)) {
            finished->MaybeReject(aReason);
          }
          return;
        }

        // 7.3: Mark as handled transition's ready promise.
        if (Promise* ready = aVt->GetReady(aRv)) {
          MOZ_ALWAYS_TRUE(ready->SetAnyPromiseIsHandled());
        }
        aVt->SkipTransition(SkipTransitionReason::UpdateCallbackRejected,
                            aReason);
      },
      RefPtr(this));

  // Step 9: To skip a transition after a timeout, the user agent may perform
  // the following steps in parallel:
  MOZ_ASSERT(!mTimeoutTimer);
  ClearTimeoutTimer();  // Be safe just in case.
  mTimeoutTimer = NS_NewTimer();
  mTimeoutTimer->InitWithNamedFuncCallback(
      TimeoutCallback, this, StaticPrefs::dom_viewTransitions_timeout_ms(),
      nsITimer::TYPE_ONE_SHOT, "ViewTransition::TimeoutCallback"_ns);
}

void ViewTransition::ClearTimeoutTimer() {
  if (mTimeoutTimer) {
    mTimeoutTimer->Cancel();
    mTimeoutTimer = nullptr;
  }
}

void ViewTransition::TimeoutCallback(nsITimer* aTimer, void* aClosure) {
  RefPtr vt = static_cast<ViewTransition*>(aClosure);
  MOZ_DIAGNOSTIC_ASSERT(aTimer == vt->mTimeoutTimer);
  vt->Timeout();
}

void ViewTransition::Timeout() {
  ClearTimeoutTimer();
  if (mPhase != Phase::Done && mDocument) {
    SkipTransition(SkipTransitionReason::Timeout);
  }
}

static already_AddRefed<Element> MakePseudo(Document& aDoc,
                                            PseudoStyleType aType,
                                            nsAtom* aName) {
  RefPtr<Element> el = aDoc.CreateHTMLElement(nsGkAtoms::div);
  if (aType == PseudoStyleType::MozSnapshotContainingBlock) {
    el->SetIsNativeAnonymousRoot();
  }
  el->SetPseudoElementType(aType);
  if (aName) {
    el->SetAttr(nsGkAtoms::name, nsDependentAtomString(aName), IgnoreErrors());
  }
  // This is not needed, but useful for debugging.
  el->SetAttr(nsGkAtoms::type,
              nsDependentAtomString(PseudoStyle::GetAtom(aType)),
              IgnoreErrors());
  return el.forget();
}

static bool SetProp(StyleLockedDeclarationBlock* aDecls, Document* aDoc,
                    NonCustomCSSPropertyId aProp, const nsACString& aValue) {
  return Servo_DeclarationBlock_SetPropertyById(
      aDecls, aProp, &aValue,
      /* is_important = */ false, aDoc->DefaultStyleAttrURLData(),
      StyleParsingMode::DEFAULT, eCompatibility_FullStandards,
      &aDoc->EnsureCSSLoader(), StyleCssRuleType::Style, {});
}

static bool SetProp(StyleLockedDeclarationBlock* aDecls, Document*,
                    NonCustomCSSPropertyId aProp, float aLength,
                    nsCSSUnit aUnit) {
  return Servo_DeclarationBlock_SetLengthValue(aDecls, aProp, aLength, aUnit);
}

static bool SetProp(StyleLockedDeclarationBlock* aDecls, Document*,
                    NonCustomCSSPropertyId aProp,
                    const CSSToCSSMatrix4x4Flagged& aM) {
  MOZ_ASSERT(aProp == eCSSProperty_transform);
  AutoTArray<StyleTransformOperation, 1> ops;
  ops.AppendElement(
      StyleTransformOperation::Matrix3D(StyleGenericMatrix3D<StyleNumber>{
          aM._11, aM._12, aM._13, aM._14, aM._21, aM._22, aM._23, aM._24,
          aM._31, aM._32, aM._33, aM._34, aM._41, aM._42, aM._43, aM._44}));
  return Servo_DeclarationBlock_SetTransform(aDecls, aProp, &ops);
}

static bool SetProp(StyleLockedDeclarationBlock* aDecls, Document* aDoc,
                    NonCustomCSSPropertyId aProp,
                    const StyleWritingModeProperty aWM) {
  return Servo_DeclarationBlock_SetKeywordValue(aDecls, aProp, (int32_t)aWM);
}

static bool SetProp(StyleLockedDeclarationBlock* aDecls, Document* aDoc,
                    NonCustomCSSPropertyId aProp,
                    const StyleDirection aDirection) {
  return Servo_DeclarationBlock_SetKeywordValue(aDecls, aProp,
                                                (int32_t)aDirection);
}

static bool SetProp(StyleLockedDeclarationBlock* aDecls, Document* aDoc,
                    NonCustomCSSPropertyId aProp,
                    const StyleTextOrientation aTextOrientation) {
  return Servo_DeclarationBlock_SetKeywordValue(aDecls, aProp,
                                                (int32_t)aTextOrientation);
}

static bool SetProp(StyleLockedDeclarationBlock* aDecls, Document* aDoc,
                    NonCustomCSSPropertyId aProp, const StyleBlend aBlend) {
  return Servo_DeclarationBlock_SetKeywordValue(aDecls, aProp, (int32_t)aBlend);
}

static bool SetProp(
    StyleLockedDeclarationBlock* aDecls, Document*,
    NonCustomCSSPropertyId aProp,
    const StyleOwnedSlice<mozilla::StyleFilter>& aBackdropFilters) {
  return Servo_DeclarationBlock_SetBackdropFilter(aDecls, aProp,
                                                  &aBackdropFilters);
}

static bool SetProp(StyleLockedDeclarationBlock* aDecls, Document*,
                    NonCustomCSSPropertyId aProp,
                    const StyleColorScheme& aColorScheme) {
  return Servo_DeclarationBlock_SetColorScheme(aDecls, aProp, &aColorScheme);
}

static StyleLockedDeclarationBlock* EnsureRule(
    RefPtr<StyleLockedDeclarationBlock>& aRule) {
  if (!aRule) {
    aRule = Servo_DeclarationBlock_CreateEmpty().Consume();
  }
  return aRule.get();
}

static nsTArray<Keyframe> BuildGroupKeyframes(
    Document* aDoc, const CSSToCSSMatrix4x4Flagged& aTransform,
    const nsSize& aSize, const StyleOwnedSlice<StyleFilter>& aBackdropFilters) {
  Keyframe firstKeyframe;
  firstKeyframe.mOffset = Some(Keyframe::OffsetType::PercentageOffset(0.0));
  PropertyValuePair transform{
      CSSPropertyId(eCSSProperty_transform),
      Servo_DeclarationBlock_CreateEmpty().Consume(),
  };
  SetProp(transform.mServoDeclarationBlock, aDoc, eCSSProperty_transform,
          aTransform);
  PropertyValuePair width{
      CSSPropertyId(eCSSProperty_width),
      Servo_DeclarationBlock_CreateEmpty().Consume(),
  };
  CSSSize cssSize = CSSSize::FromAppUnits(aSize);
  SetProp(width.mServoDeclarationBlock, aDoc, eCSSProperty_width, cssSize.width,
          eCSSUnit_Pixel);
  PropertyValuePair height{
      CSSPropertyId(eCSSProperty_height),
      Servo_DeclarationBlock_CreateEmpty().Consume(),
  };
  SetProp(height.mServoDeclarationBlock, aDoc, eCSSProperty_height,
          cssSize.height, eCSSUnit_Pixel);
  PropertyValuePair backdropFilters{
      CSSPropertyId(eCSSProperty_backdrop_filter),
      Servo_DeclarationBlock_CreateEmpty().Consume(),
  };
  SetProp(backdropFilters.mServoDeclarationBlock, aDoc,
          eCSSProperty_backdrop_filter, aBackdropFilters);
  firstKeyframe.mPropertyValues.AppendElement(std::move(transform));
  firstKeyframe.mPropertyValues.AppendElement(std::move(width));
  firstKeyframe.mPropertyValues.AppendElement(std::move(height));
  firstKeyframe.mPropertyValues.AppendElement(std::move(backdropFilters));

  Keyframe lastKeyframe;
  lastKeyframe.mOffset = Some(Keyframe::OffsetType::PercentageOffset(1.0));
  lastKeyframe.mPropertyValues.AppendElement(
      PropertyValuePair{CSSPropertyId(eCSSProperty_transform)});
  lastKeyframe.mPropertyValues.AppendElement(
      PropertyValuePair{CSSPropertyId(eCSSProperty_width)});
  lastKeyframe.mPropertyValues.AppendElement(
      PropertyValuePair{CSSPropertyId(eCSSProperty_height)});
  lastKeyframe.mPropertyValues.AppendElement(
      PropertyValuePair{CSSPropertyId(eCSSProperty_backdrop_filter)});

  nsTArray<Keyframe> result;
  result.AppendElement(std::move(firstKeyframe));
  result.AppendElement(std::move(lastKeyframe));
  return result;
}

bool ViewTransition::GetGroupKeyframes(
    nsAtom* aAnimationName, const StyleComputedTimingFunction& aTimingFunction,
    nsTArray<Keyframe>& aResult) {
  MOZ_ASSERT(StringBeginsWith(nsDependentAtomString(aAnimationName),
                              kGroupAnimPrefix));
  RefPtr<nsAtom> transitionName = NS_Atomize(Substring(
      nsDependentAtomString(aAnimationName), kGroupAnimPrefix.Length()));
  auto* el = mNamedElements.Get(transitionName);
  if (NS_WARN_IF(!el) || NS_WARN_IF(el->mGroupKeyframes.IsEmpty())) {
    return false;
  }
  aResult = el->mGroupKeyframes.Clone();
  // We assign the timing function always to make sure we don't use the default
  // linear timing function.
  MOZ_ASSERT(aResult.Length() == 2);
  aResult[0].mTimingFunction = Some(aTimingFunction);
  aResult[1].mTimingFunction = Some(aTimingFunction);
  return true;
}

// Matches the class list in the captured element.
// https://drafts.csswg.org/css-view-transitions-2/#pseudo-element-class-additions
bool ViewTransition::MatchClassList(
    nsAtom* aTransitionName,
    const nsTArray<StyleAtom>& aPtNameAndClassSelector) const {
  MOZ_ASSERT(aPtNameAndClassSelector.Length() > 1,
             "Should have a vt-class selector");
  MOZ_ASSERT(aTransitionName, "No transition name?");

  const auto* el = mNamedElements.Get(aTransitionName);
  MOZ_ASSERT(el,
             "Our caller should have the view transition pseudo handy, how do "
             "we have no capture?");
  if (MOZ_UNLIKELY(!el)) {
    // FIXME: We see some instances of this on the wild (bug 2010608), but have
    // no repro for it. For now not matching is pretty safe...
    return false;
  }
  const auto& classList = el->mClassList.value._0.AsSpan();
  if (classList.IsEmpty()) {
    return false;
  }
  auto hasClass = [&classList](nsAtom* aClass) {
    // Linear search. The css class list shouldn't be very large in most cases.
    for (const auto& ident : classList) {
      if (ident.AsAtom() == aClass) {
        return true;
      }
    }
    return false;
  };

  // A named view transition pseudo-element selector which has one or more
  // <custom-ident> values in its <pt-class-selector> would only match an
  // element if the class list value in named elements for the pseudo-element’s
  // view-transition-name contains all of those values.
  // i.e. |aPtNameAndClassSelector| should be a subset of |mClassList|.
  for (const auto& atom : Span(aPtNameAndClassSelector).From(1)) {
    if (!hasClass(atom.AsAtom())) {
      return false;
    }
  }
  return true;
}

// In general, we are trying to generate the following pseudo-elements tree:
// ::-moz-snapshot-containing-block
// └─ ::view-transition
//    ├─ ::view-transition-group(name)
//    │  └─ ::view-transition-image-pair(name)
//    │     ├─ ::view-transition-old(name)
//    │     └─ ::view-transition-new(name)
//    └─ ...other groups...
//
// ::-moz-snapshot-containing-block is the top-layer of the tree. It is the
// wrapper of the view transition pseudo-elements tree for the snapshot
// containing block concept. And it is the child of the document element.
// https://drafts.csswg.org/css-view-transitions-1/#setup-transition-pseudo-elements
void ViewTransition::SetupTransitionPseudoElements() {
  MOZ_ASSERT(!mSnapshotContainingBlock);

  nsAutoScriptBlocker scriptBlocker;

  RefPtr docElement = mDocument->GetRootElement();
  if (!docElement) {
    return;
  }

  // We don't need to notify while constructing the tree.
  constexpr bool kNotify = false;

  // Step 1 is a declaration.

  // Step 2: Set document's show view transition tree to true.
  // (we lazily create this pseudo-element so we don't need the flag for now at
  // least).
  // Note: Use mSnapshotContainingBlock to wrap the pseudo-element tree.
  mSnapshotContainingBlock = MakePseudo(
      *mDocument, PseudoStyleType::MozSnapshotContainingBlock, nullptr);
  RefPtr<Element> root =
      MakePseudo(*mDocument, PseudoStyleType::ViewTransition, nullptr);
  mSnapshotContainingBlock->AppendChildTo(root, kNotify, IgnoreErrors());
#ifdef DEBUG
  // View transition pseudos don't care about frame tree ordering, so can be
  // restyled just fine.
  mSnapshotContainingBlock->SetProperty(nsGkAtoms::restylableAnonymousNode,
                                        reinterpret_cast<void*>(true));
#endif

  MOZ_ASSERT(mNames.Length() == mNamedElements.Count());
  // Step 3: For each transitionName -> capturedElement of transition’s named
  // elements:
  for (nsAtom* transitionName : mNames) {
    CapturedElement& capturedElement = *mNamedElements.Get(transitionName);
    // Let group be a new ::view-transition-group(), with its view transition
    // name set to transitionName.
    RefPtr<Element> group = MakePseudo(
        *mDocument, PseudoStyleType::ViewTransitionGroup, transitionName);
    // Append group to transition’s transition root pseudo-element.
    root->AppendChildTo(group, kNotify, IgnoreErrors());
    // Let imagePair be a new ::view-transition-image-pair(), with its view
    // transition name set to transitionName.
    RefPtr<Element> imagePair = MakePseudo(
        *mDocument, PseudoStyleType::ViewTransitionImagePair, transitionName);
    // Append imagePair to group.
    group->AppendChildTo(imagePair, kNotify, IgnoreErrors());
    // If capturedElement's old image is not null, then:
    if (capturedElement.mOldState.mTriedImage) {
      // Let old be a new ::view-transition-old(), with its view transition
      // name set to transitionName, displaying capturedElement's old image as
      // its replaced content.
      RefPtr<Element> old = MakePseudo(
          *mDocument, PseudoStyleType::ViewTransitionOld, transitionName);
      // Append old to imagePair.
      imagePair->AppendChildTo(old, kNotify, IgnoreErrors());
    } else {
      // Moved around for simplicity. If capturedElement's old image is null,
      // then: Assert: capturedElement's new element is not null.
      MOZ_ASSERT(capturedElement.mNewElement);
      // Set capturedElement's image animation name rule to a new ...
      auto* rule = EnsureRule(capturedElement.mNewRule);
      SetProp(rule, mDocument, eCSSProperty_animation_name,
              "-ua-view-transition-fade-in"_ns);
    }
    // If capturedElement's new element is not null, then:
    if (capturedElement.mNewElement) {
      // Let new be a new ::view-transition-new(), with its view transition
      // name set to transitionName.
      RefPtr<Element> new_ = MakePseudo(
          *mDocument, PseudoStyleType::ViewTransitionNew, transitionName);
      // Append new to imagePair.
      imagePair->AppendChildTo(new_, kNotify, IgnoreErrors());
    } else {
      // Moved around from the next step for simplicity.
      // Assert: capturedElement's old image is not null.
      // Set capturedElement's image animation name rule to a new CSSStyleRule
      // representing the following CSS, and append it to document’s dynamic
      // view transition style sheet:
      MOZ_ASSERT(capturedElement.mOldState.mTriedImage);
      SetProp(EnsureRule(capturedElement.mOldRule), mDocument,
              eCSSProperty_animation_name, "-ua-view-transition-fade-out"_ns);

      // Moved around from "update pseudo-element styles" because it's a one
      // time operation.
      auto* rule = EnsureRule(capturedElement.mGroupRule);
      auto oldRect =
          CSSPixel::FromAppUnits(capturedElement.mOldState.mBorderBoxSize);
      SetProp(rule, mDocument, eCSSProperty_width, oldRect.width,
              eCSSUnit_Pixel);
      SetProp(rule, mDocument, eCSSProperty_height, oldRect.height,
              eCSSUnit_Pixel);
      SetProp(rule, mDocument, eCSSProperty_transform,
              capturedElement.mOldState.mTransform);
      SetProp(rule, mDocument, eCSSProperty_writing_mode,
              capturedElement.mOldState.mWritingMode);
      SetProp(rule, mDocument, eCSSProperty_direction,
              capturedElement.mOldState.mDirection);
      SetProp(rule, mDocument, eCSSProperty_text_orientation,
              capturedElement.mOldState.mTextOrientation);
      SetProp(rule, mDocument, eCSSProperty_mix_blend_mode,
              capturedElement.mOldState.mMixBlendMode);
      SetProp(rule, mDocument, eCSSProperty_backdrop_filter,
              capturedElement.mOldState.mBackdropFilters);
      SetProp(rule, mDocument, eCSSProperty_color_scheme,
              capturedElement.mOldState.mColorScheme);
    }
    // If both of capturedElement's old image and new element are not null,
    // then:
    if (capturedElement.mOldState.mTriedImage && capturedElement.mNewElement) {
      nsAutoCString dynamicAnimationName;
      nsStyleUtil::AppendQuotedCSSString(
          NS_ConvertUTF16toUTF8(kGroupAnimPrefix +
                                nsDependentAtomString(transitionName)),
          dynamicAnimationName);
      capturedElement.mGroupKeyframes =
          BuildGroupKeyframes(mDocument, capturedElement.mOldState.mTransform,
                              capturedElement.mOldState.mBorderBoxSize,
                              capturedElement.mOldState.mBackdropFilters);
      // Set capturedElement's group animation name rule to ...
      SetProp(EnsureRule(capturedElement.mGroupRule), mDocument,
              eCSSProperty_animation_name, dynamicAnimationName);

      // Set capturedElement's image pair isolation rule to ...
      SetProp(EnsureRule(capturedElement.mImagePairRule), mDocument,
              eCSSProperty_isolation, "isolate"_ns);

      // Set capturedElement's image animation name rule to ...
      SetProp(
          EnsureRule(capturedElement.mOldRule), mDocument,
          eCSSProperty_animation_name,
          "-ua-view-transition-fade-out, -ua-mix-blend-mode-plus-lighter"_ns);
      SetProp(
          EnsureRule(capturedElement.mNewRule), mDocument,
          eCSSProperty_animation_name,
          "-ua-view-transition-fade-in, -ua-mix-blend-mode-plus-lighter"_ns);
    }
  }
  BindContext context(*docElement, BindContext::ForNativeAnonymous);
  if (NS_FAILED(mSnapshotContainingBlock->BindToTree(context, *docElement))) {
    mSnapshotContainingBlock->UnbindFromTree();
    mSnapshotContainingBlock = nullptr;
    return;
  }
  if (mDocument->DevToolsAnonymousAndShadowEventsEnabled()) {
    mSnapshotContainingBlock->QueueDevtoolsAnonymousEvent(
        /* aIsRemove = */ false);
  }
  if (PresShell* ps = mDocument->GetPresShell()) {
    ps->ContentAppended(mSnapshotContainingBlock, {});
  }
}

// https://drafts.csswg.org/css-view-transitions-1/#style-transition-pseudo-elements-algorithm
bool ViewTransition::UpdatePseudoElementStyles(bool aNeedsInvalidation) {
  // 1. For each transitionName -> capturedElement of transition's "named
  // elements".
  for (auto& entry : mNamedElements) {
    nsAtom* transitionName = entry.GetKey();
    CapturedElement& capturedElement = *entry.GetData();
    // If capturedElement's new element is null, then:
    // We already did this in SetupTransitionPseudoElements().
    if (!capturedElement.mNewElement) {
      continue;
    }
    // Otherwise.
    // Return failure if any of the following conditions is true:
    //  * capturedElement's new element has a flat tree ancestor that skips its
    //    contents.
    //  * capturedElement's new element is not rendered.
    //  * capturedElement has more than one box fragment.
    nsIFrame* frame = capturedElement.mNewElement->GetPrimaryFrame();
    if (!frame || frame->IsHiddenByContentVisibilityOnAnyAncestor() ||
        frame->GetPrevContinuation() || frame->GetNextContinuation()) {
      return false;
    }
    auto* rule = EnsureRule(capturedElement.mGroupRule);
    // Note: mInitialSnapshotContainingBlockSize should be the same as the
    // current snapshot containing block size because the caller checks it
    // before calling us.
    const auto newBorderBoxSize =
        CapturedRect(frame, mInitialSnapshotContainingBlockSize,
                     CapturedRectType::BorderBox)
            .Size();
    auto size = CSSPixel::FromAppUnits(newBorderBoxSize);
    // NOTE(emilio): Intentionally not short-circuiting. Int cast is needed to
    // silence warning.
    bool groupStyleChanged =
        int(SetProp(rule, mDocument, eCSSProperty_width, size.width,
                    eCSSUnit_Pixel)) |
        SetProp(rule, mDocument, eCSSProperty_height, size.height,
                eCSSUnit_Pixel) |
        SetProp(rule, mDocument, eCSSProperty_transform,
                EffectiveTransform(frame)) |
        SetProp(rule, mDocument, eCSSProperty_writing_mode,
                frame->StyleVisibility()->mWritingMode) |
        SetProp(rule, mDocument, eCSSProperty_direction,
                frame->StyleVisibility()->mDirection) |
        SetProp(rule, mDocument, eCSSProperty_text_orientation,
                frame->StyleVisibility()->mTextOrientation) |
        SetProp(rule, mDocument, eCSSProperty_mix_blend_mode,
                frame->StyleEffects()->mMixBlendMode) |
        SetProp(rule, mDocument, eCSSProperty_backdrop_filter,
                frame->StyleEffects()->mBackdropFilters) |
        SetProp(rule, mDocument, eCSSProperty_color_scheme,
                frame->StyleUI()->mColorScheme);
    if (groupStyleChanged && aNeedsInvalidation) {
      auto* pseudo = FindPseudo(PseudoStyleRequest(
          PseudoStyleType::ViewTransitionGroup, transitionName));
      MOZ_ASSERT(pseudo);
      // TODO(emilio): Maybe we need something more than recascade? But I don't
      // see how off-hand.
      nsLayoutUtils::PostRestyleEvent(pseudo, RestyleHint::RECASCADE_SELF,
                                      nsChangeHint(0));
    }

    // 5. Live capturing (nothing to do here regarding the capture itself, but
    // if the size has changed, then we need to invalidate the new frame).
    const auto newSnapshotRect =
        CapturedRect(frame, mInitialSnapshotContainingBlockSize,
                     CapturedRectType::InkOverflowBox);
    auto oldRect = capturedElement.mNewSnapshotRect;
    capturedElement.mNewSnapshotRect = newSnapshotRect;
    capturedElement.mNewBorderBoxSize = newBorderBoxSize;
    if (!oldRect.IsEqualEdges(capturedElement.mNewSnapshotRect) &&
        aNeedsInvalidation) {
      frame->PresShell()->FrameNeedsReflow(
          frame, IntrinsicDirty::FrameAndAncestors, NS_FRAME_IS_DIRTY);
    }
  }
  return true;
}

// https://drafts.csswg.org/css-view-transitions-1/#activate-view-transition
void ViewTransition::Activate() {
  AUTO_PROFILER_FLOW_MARKER("ViewTransition::Activate", LAYOUT,
                            Flow::FromPointer(this));
  // Step 1: If transition's phase is "done", then return.
  if (mPhase == Phase::Done) {
    return;
  }

  // Step 2: Set transition’s relevant global object’s associated document’s
  // rendering suppression for view transitions to false.
  mDocument->SetRenderingSuppressedForViewTransitions(false);

  // Step 3: If transition's initial snapshot containing block size is not
  // equal to the snapshot containing block size, then skip the view transition
  // for transition, and return.
  if (mInitialSnapshotContainingBlockSize !=
      SnapshotContainingBlockRect().Size()) {
    return SkipTransition(SkipTransitionReason::Resize);
  }

  // Step 4: Capture the new state for transition.
  // Step 5 is done along step 4 for performance.
  if (auto skipReason = CaptureNewState()) {
    // We clear named elements to not leave lingering "captured in a view
    // transition" state.
    ClearNamedElements();
    // If failure is returned, then skip the view transition for transition...
    return SkipTransition(*skipReason);
  }

  // Step 6: Setup transition pseudo-elements for transition.
  SetupTransitionPseudoElements();

  // Step 7: Update pseudo-element styles for transition.
  // We don't need to invalidate the pseudo-element styles since we just
  // generated them.
  if (!UpdatePseudoElementStyles(/* aNeedsInvalidation = */ false)) {
    // If failure is returned, then skip the view transition for transition
    // with an "InvalidStateError" DOMException in transition's relevant Realm,
    // and return.
    return SkipTransition(SkipTransitionReason::PseudoUpdateFailure);
  }

  // Step 8: Set transition's phase to "animating".
  mPhase = Phase::Animating;
  // Step 9: Resolve transition's ready promise.
  if (Promise* ready = GetReady(IgnoreErrors())) {
    ready->MaybeResolveWithUndefined();
  }

  // Once this view transition is activated, we have to perform the pending
  // operations periodically.
  MOZ_ASSERT(mDocument);
  mDocument->EnsureViewTransitionOperationsHappen();
}

// https://drafts.csswg.org/css-view-transitions/#perform-pending-transition-operations
void ViewTransition::PerformPendingOperations() {
  MOZ_ASSERT(mDocument);
  MOZ_ASSERT(mDocument->GetActiveViewTransition() == this);
  AUTO_PROFILER_FLOW_MARKER("ViewTransition::PerformPendingOperations", LAYOUT,
                            Flow::FromPointer(this));

  // Flush the update callback queue.
  // Note: this ensures that any changes to the DOM scheduled by other skipped
  // transitions are done before the old state for this transition is captured.
  // https://github.com/w3c/csswg-drafts/issues/11943
  RefPtr doc = mDocument;
  doc->FlushViewTransitionUpdateCallbackQueue();

  switch (mPhase) {
    case Phase::PendingCapture:
      return Setup();
    case Phase::Animating:
      return HandleFrame();
    default:
      break;
  }
}

// https://drafts.csswg.org/css-view-transitions/#snapshot-containing-block
nsRect ViewTransition::SnapshotContainingBlockRect(nsPresContext* aPc) {
  return aPc ? nsRect(aPc->GetVisibleArea().TopLeft(),
                      aPc->GetSizeForViewportUnits())
             : nsRect();
}

// https://drafts.csswg.org/css-view-transitions/#snapshot-containing-block
nsRect ViewTransition::SnapshotContainingBlockRect() const {
  nsPresContext* pc = mDocument->GetPresContext();
  return SnapshotContainingBlockRect(pc);
}

nsRect ViewTransition::CapturedInkOverflowRectForFrame(nsIFrame* aFrame,
                                                       bool aIsRoot) {
  auto snapshotCb = SnapshotContainingBlockRect(aFrame->PresContext());
  if (aIsRoot) {
    return snapshotCb;
  }
  return CapturedRect(aFrame, snapshotCb.Size(),
                      CapturedRectType::InkOverflowBox);
}

Element* ViewTransition::FindPseudo(const PseudoStyleRequest& aRequest) const {
  Element* root = GetViewTransitionTreeRoot();
  if (!root) {
    return nullptr;
  }
  MOZ_ASSERT(root->GetPseudoElementType() == PseudoStyleType::ViewTransition);

  if (aRequest.mType == PseudoStyleType::ViewTransition) {
    return root;
  }

  // Linear search ::view-transition-group by |aRequest.mIdentifier|.
  // Note: perhaps we can add a hashtable to improve the performance if it's
  // common that there are a lot of view-transition-names.
  Element* group = root->GetFirstElementChild();
  for (; group; group = group->GetNextElementSibling()) {
    MOZ_ASSERT(group->HasName(),
               "The generated ::view-transition-group() should have a name");
    nsAtom* name = group->GetParsedAttr(nsGkAtoms::name)->GetAtomValue();
    if (name == aRequest.mIdentifier) {
      break;
    }
  }

  // No one specifies view-transition-name or we mismatch all names.
  if (!group) {
    return nullptr;
  }

  if (aRequest.mType == PseudoStyleType::ViewTransitionGroup) {
    return group;
  }

  Element* imagePair = group->GetFirstElementChild();
  MOZ_ASSERT(imagePair, "::view-transition-image-pair() should exist always");
  if (aRequest.mType == PseudoStyleType::ViewTransitionImagePair) {
    return imagePair;
  }

  Element* child = imagePair->GetFirstElementChild();
  // Neither ::view-transition-old() nor ::view-transition-new() doesn't exist.
  if (!child) {
    return nullptr;
  }

  // Check if the first element matches our request.
  const PseudoStyleType type = child->GetPseudoElementType();
  if (type == aRequest.mType) {
    return child;
  }

  // Since the second child is either ::view-transition-new() or nullptr, so we
  // can reject viewTransitionOld request here.
  if (aRequest.mType == PseudoStyleType::ViewTransitionOld) {
    return nullptr;
  }

  child = child->GetNextElementSibling();
  MOZ_ASSERT(aRequest.mType == PseudoStyleType::ViewTransitionNew);
  MOZ_ASSERT(!child || !child->GetNextElementSibling(),
             "No more psuedo elements in this subtree");
  return child;
}

const StyleLockedDeclarationBlock* ViewTransition::GetDynamicRuleFor(
    const Element& aElement) const {
  if (!aElement.HasName()) {
    return nullptr;
  }
  nsAtom* name = aElement.GetParsedAttr(nsGkAtoms::name)->GetAtomValue();
  auto* capture = mNamedElements.Get(name);
  if (!capture) {
    return nullptr;
  }

  switch (aElement.GetPseudoElementType()) {
    case PseudoStyleType::ViewTransitionNew:
      return capture->mNewRule.get();
    case PseudoStyleType::ViewTransitionOld:
      return capture->mOldRule.get();
    case PseudoStyleType::ViewTransitionImagePair:
      return capture->mImagePairRule.get();
    case PseudoStyleType::ViewTransitionGroup:
      return capture->mGroupRule.get();
    default:
      return nullptr;
  }
}

// This function collects frames in the same stacking context. We only put
// the frames which may create a new create stacking context in the list because
// they (and their descendants) are candidates for captured elements (i.e. with
// a valid view-transition-name).
static void CollectDescendantStackingContexts(nsIFrame* aStackingContextRoot,
                                              nsTArray<nsIFrame*>& aList) {
  for (auto& [list, id] : aStackingContextRoot->ChildLists()) {
    for (nsIFrame* f : list) {
      // FIXME: We probably can skip more frames, e.g. scrollbar or scrollcorner
      // to save some time.

      // We only want to sort the frames form a new stacking context in the
      // current stacking context (including the root stacking context). If it
      // creates a new stacking context, its descendants should be traversed
      // (and sorted) independently. Also, if a frame has view-transition-name,
      // it should create a stacking context as well, so this check must include
      // frames with view-transition-name.
      // Note: the root frame may not be the root element, so we still have to
      // check if |f| is the root element.
      if (f->Style()->IsRootElementStyle() || f->IsStackingContext()) {
        aList.AppendElement(f);
        // We will continue to traverse its descendants after we sort |aList|.
        continue;
      }

      // If any flat tree ancestor of this element skips its contents, then
      // continue.
      if (f->IsHiddenByContentVisibilityOnAnyAncestor()) {
        continue;
      }

      // If |insertionFrame| doesn't create stacking context, we have to check
      // its descendants because they are still in the current stacking context.
      CollectDescendantStackingContexts(f, aList);
    }
  }
}

struct ZOrderComparator {
  bool LessThan(const nsIFrame* aLeft, const nsIFrame* aRight) const {
    return aLeft->ZIndex().valueOr(0) < aRight->ZIndex().valueOr(0);
  }
};

template <typename Callback>
static bool ForEachDescendantWithViewTransitionNameInPaintOrder(
    nsIFrame* aFrame, const Callback& aCb) {
  // Call the callback if it specifies view-transition-name.
  if (aFrame->StyleUIReset()->HasViewTransitionName() && !aCb(aFrame)) {
    return false;
  }

  nsTArray<nsIFrame*> descendantStackingContexts;
  CollectDescendantStackingContexts(aFrame, descendantStackingContexts);
  // Sort by z-index to make sure we call the callback in paint order.
  descendantStackingContexts.StableSort(ZOrderComparator());

  for (nsIFrame* f : descendantStackingContexts) {
    if (!ForEachDescendantWithViewTransitionNameInPaintOrder(f, aCb)) {
      return false;
    }
  }
  return true;
}

template <typename Callback>
static void ForEachFrameWithViewTransitionName(Document* aDoc,
                                               const Callback& aCb) {
  PresShell* ps = aDoc->GetPresShell();
  if (!ps) {
    return;
  }
  nsIFrame* root = ps->GetRootFrame();
  if (!root) {
    return;
  }
  ForEachDescendantWithViewTransitionNameInPaintOrder(root, aCb);
}

// https://drafts.csswg.org/css-view-transitions/#capture-the-old-state
Maybe<SkipTransitionReason> ViewTransition::CaptureOldState() {
  MOZ_ASSERT(mNamedElements.IsEmpty());

  // Steps 1/2 are variable declarations.
  // Step 3: Let usedTransitionNames be a new set of strings.
  nsTHashSet<nsAtom*> usedTransitionNames;
  // Step 4: Let captureElements be a new list of elements.
  OldCaptureFramesArray captureElements;

  // Step 5: If the snapshot containing block size exceeds an
  // implementation-defined maximum, then return failure.
  // TODO(emilio): Implement a maximum if we deem it needed.
  //
  // Step 6: Set transition's initial snapshot containing block size to the
  // snapshot containing block size.
  mInitialSnapshotContainingBlockSize = SnapshotContainingBlockRect().Size();

  // Step 7: For each element of every element that is connected, and has a node
  // document equal to document, in paint order:
  Maybe<SkipTransitionReason> result;
  ForEachFrameWithViewTransitionName(mDocument, [&](nsIFrame* aFrame) {
    RefPtr<nsAtom> name = DocumentScopedTransitionNameFor(aFrame);
    if (!name) {
      // As a fast path we check for v-t-n first.
      // If transitionName is none, or element is not rendered, then continue.
      return true;
    }
    if (aFrame->IsHiddenByContentVisibilityOnAnyAncestor()) {
      // See https://github.com/w3c/csswg-drafts/issues/13831
      return true;
    }
    if (aFrame->GetPrevContinuation() || aFrame->GetNextContinuation()) {
      // If element has more than one box fragment, then continue.
      return true;
    }
    if (!usedTransitionNames.EnsureInserted(name)) {
      // We don't expect to see a duplicate transition name when using
      // match-element.
      MOZ_ASSERT(aFrame->StyleUIReset()->mViewTransitionName.value.AsAtom() !=
                 nsGkAtoms::match_element);

      // If usedTransitionNames contains transitionName, then return failure.
      result.emplace(
          SkipTransitionReason::DuplicateTransitionNameCapturingOldState);
      return false;
    }
    SetCaptured(aFrame, true, name.get());
    captureElements.AppendElement(std::make_pair(aFrame, std::move(name)));
    return true;
  });

  if (result) {
    for (auto& [f, name] : captureElements) {
      SetCaptured(f, false, nullptr);
    }
    return result;
  }

  // Step 8: For each element in captureElements:
  // Step 9: For each element in captureElements, set element's captured
  // in a view transition to false.
  for (auto& [f, name] : captureElements) {
    MOZ_ASSERT(f);
    MOZ_ASSERT(f->GetContent()->IsElement());
    // Capture the view-transition-class.
    // https://drafts.csswg.org/css-view-transitions-2/#vt-class-algorithms
    auto capture = MakeUnique<CapturedElement>(
        f, mInitialSnapshotContainingBlockSize, DocumentScopedClassListFor(f));
    mNamedElements.InsertOrUpdate(name, std::move(capture));
    mNames.AppendElement(name);
  }

  if (!captureElements.IsEmpty()) {
    AutoRestore guard{mOldCaptureElements};
    mOldCaptureElements = &captureElements;
    // When snapshotting an iframe, we need to paint from the root subdoc.
    if (RefPtr<PresShell> ps =
            nsContentUtils::GetInProcessSubtreeRootDocument(mDocument)
                ->GetPresShell()) {
      // Build a display list and send it to WR in order to perform the
      // capturing of old content.
      if (RefPtr widget = ps->GetRootWidget()) {
        VT_LOG("ViewTransitions::CaptureOldState(), requesting composite");
        ps->PaintAndRequestComposite(ps->GetRootFrame(),
                                     widget->GetWindowRenderer(),
                                     PaintFlags::PaintCompositeOffscreen);
        VT_LOG("ViewTransitions::CaptureOldState(), requesting composite end");
      }
    }
  }

  for (auto& [f, name] : captureElements) {
    SetCaptured(f, false, nullptr);
  }
  return result;
}

// https://drafts.csswg.org/css-view-transitions-1/#capture-the-new-state
Maybe<SkipTransitionReason> ViewTransition::CaptureNewState() {
  nsTHashSet<nsAtom*> usedTransitionNames;
  Maybe<SkipTransitionReason> result;
  ForEachFrameWithViewTransitionName(mDocument, [&](nsIFrame* aFrame) {
    // As a fast path we check for v-t-n first.
    RefPtr<nsAtom> name = DocumentScopedTransitionNameFor(aFrame);
    if (!name) {
      return true;
    }
    if (aFrame->IsHiddenByContentVisibilityOnAnyAncestor()) {
      // See https://github.com/w3c/csswg-drafts/issues/13831
      return true;
    }
    if (aFrame->GetPrevContinuation() || aFrame->GetNextContinuation()) {
      // If element has more than one box fragment, then continue.
      return true;
    }
    if (!usedTransitionNames.EnsureInserted(name)) {
      // We don't expect to see a duplicate transition name when using
      // match-element.
      MOZ_ASSERT(aFrame->StyleUIReset()->mViewTransitionName.value.AsAtom() !=
                 nsGkAtoms::match_element);
      result.emplace(
          SkipTransitionReason::DuplicateTransitionNameCapturingNewState);
      return false;
    }
    bool wasPresent = true;
    auto& capturedElement = mNamedElements.LookupOrInsertWith(name, [&] {
      wasPresent = false;
      return MakeUnique<CapturedElement>();
    });
    if (!wasPresent) {
      mNames.AppendElement(name);
    }
    capturedElement->mNewElement = aFrame->GetContent()->AsElement();
    auto capturedRect =
        CapturedRect(aFrame, mInitialSnapshotContainingBlockSize,
                     CapturedRectType::InkOverflowBox);
    // Note: mInitialSnapshotContainingBlockSize should be the same as the
    // current snapshot containing block size at this moment because the caller
    // checks it before calling us.
    capturedElement->mNewSnapshotRect = capturedRect;
    capturedElement->mNewBorderBoxSize =
        CapturedRect(aFrame, mInitialSnapshotContainingBlockSize,
                     CapturedRectType::BorderBox)
            .Size();
    // Update its class list. This may override the existing class list because
    // the users may change view-transition-class in the callback function. We
    // have to use the latest one.
    // https://drafts.csswg.org/css-view-transitions-2/#vt-class-algorithms
    capturedElement->CaptureClassList(DocumentScopedClassListFor(aFrame));
    SetCaptured(aFrame, true, name);
    return true;
  });
  return result;
}

// https://drafts.csswg.org/css-view-transitions/#setup-view-transition
void ViewTransition::Setup() {
  AUTO_PROFILER_FLOW_MARKER("ViewTransition::Setup", LAYOUT,
                            Flow::FromPointer(this));
  // Step 2: Capture the old state for transition.
  if (auto skipReason = CaptureOldState()) {
    // If failure is returned, then skip the view transition for transition
    // with an "InvalidStateError" DOMException in transition’s relevant Realm,
    // and return.
    return SkipTransition(*skipReason);
  }

  // Step 3: Set document’s rendering suppression for view transitions to true.
  mDocument->SetRenderingSuppressedForViewTransitions(true);

  // Step 4: Queue a global task on the DOM manipulation task source, given
  // transition's relevant global object, to perform the following steps:
  //   4.1: If transition's phase is "done", then abort these steps.
  //   4.2: Schedule the update callback for transition.
  //   4.3: Flush the update callback queue.
  mDocument->Dispatch(
      NewRunnableMethod("ViewTransition::MaybeScheduleUpdateCallback", this,
                        &ViewTransition::MaybeScheduleUpdateCallback));
}

void ViewTransition::FinishDone() {
  if (mPhase != Phase::PendingDone) {
    return;
  }
  // https://drafts.csswg.org/css-view-transitions-1/#handle-transition-frame
  // step 4.2: Clear view transition transition.
  ClearActiveTransition(false);
  // 4.3: Resolve transition's finished promise.
  if (Promise* finished = GetFinished(IgnoreErrors())) {
    finished->MaybeResolveWithUndefined();
  }
}

// https://drafts.csswg.org/css-view-transitions-1/#handle-transition-frame
void ViewTransition::HandleFrame() {
  // Steps 1-3: Steps 1-3: Compute active animations.
  const bool hasActiveAnimations = CheckForActiveAnimations();

  // Step 4: If hasActiveAnimations is false:
  if (!hasActiveAnimations) {
    AUTO_PROFILER_TERMINATING_FLOW_MARKER("ViewTransition::HandleFrameFinish",
                                          LAYOUT, Flow::FromPointer(this));
    // 4.1: Set transition's phase to "done".
    // NOTE: pending-done + async task per
    // https://github.com/w3c/csswg-drafts/issues/12442
    mPhase = Phase::PendingDone;
    mDocument->Dispatch(NewRunnableMethod("ViewTransition::FinishDone", this,
                                          &ViewTransition::FinishDone));
    return;
  }

  AUTO_PROFILER_FLOW_MARKER("ViewTransition::HandleFrame", LAYOUT,
                            Flow::FromPointer(this));

  // Step 5: If transition’s initial snapshot containing block size is not equal
  // to the snapshot containing block size, then skip the view transition for
  // transition with an "InvalidStateError" DOMException in transition’s
  // relevant Realm, and return.
  if (SnapshotContainingBlockRect().Size() !=
      mInitialSnapshotContainingBlockSize) {
    SkipTransition(SkipTransitionReason::Resize);
    return;
  }

  // Step 6: Update pseudo-element styles for transition.
  if (!UpdatePseudoElementStyles(/* aNeedsInvalidation= */ true)) {
    // If failure is returned, then skip the view transition for transition
    // with an "InvalidStateError" DOMException in transition's relevant Realm,
    // and return.
    return SkipTransition(SkipTransitionReason::PseudoUpdateFailure);
  }

  // If the view transition is still animating after HandleFrame(), we have to
  // periodically perform operations to check if it is still animating in the
  // following ticks.
  mDocument->EnsureViewTransitionOperationsHappen();
}

static bool CheckForActiveAnimationsForEachPseudo(
    const Element& aRoot, const AnimationTimeline& aDocTimeline,
    const AnimationEventDispatcher& aDispatcher,
    PseudoStyleRequest&& aRequest) {
  // Check EffectSet because an Animation (either a CSS Animations or a
  // script animation) is associated with a KeyframeEffect. If the animation
  // doesn't have an associated effect, we can skip it per spec.
  // If the effect target is not the element we request, it shouldn't be in
  // |effects| either.
  EffectSet* effects = EffectSet::Get(&aRoot, aRequest);
  if (!effects) {
    return false;
  }

  for (const auto* effect : *effects) {
    // 3.1: For each animation whose timeline is a document timeline associated
    // with document, and contains at least one associated effect whose effect
    // target is element, set hasActiveAnimations to true if any of the
    // following conditions is true:
    //   * animation’s play state is paused or running.
    //   * document’s pending animation event queue has any events associated
    //     with animation.

    MOZ_ASSERT(effect && effect->GetAnimation(),
               "Only effects associated with an animation should be "
               "added to an element's effect set");
    const Animation* anim = effect->GetAnimation();

    // The animation's timeline is not the document timeline.
    if (anim->GetTimeline() != &aDocTimeline) {
      continue;
    }

    // Return true if any of the following conditions is true:
    // 1. animation’s play state is paused or running.
    // 2. document’s pending animation event queue has any events associated
    //    with animation.
    const auto playState = anim->PlayState();
    if (playState != AnimationPlayState::Paused &&
        playState != AnimationPlayState::Running &&
        !aDispatcher.HasQueuedEventsFor(anim)) {
      continue;
    }
    return true;
  }
  return false;
}

// This is the implementation of step 3 in HandleFrame(). For each element of
// transition’s transition root pseudo-element’s inclusive descendants, we check
// if it has active animations.
bool ViewTransition::CheckForActiveAnimations() const {
  MOZ_ASSERT(mDocument);

  if (StaticPrefs::dom_viewTransitions_remain_active()) {
    return true;
  }

  const Element* root = mDocument->GetRootElement();
  if (!root) {
    // The documentElement could be removed during animating via script.
    return false;
  }

  const AnimationTimeline* timeline = mDocument->Timeline();
  if (!timeline) {
    return false;
  }

  nsPresContext* presContext = mDocument->GetPresContext();
  if (!presContext) {
    return false;
  }

  const AnimationEventDispatcher* dispatcher =
      presContext->AnimationEventDispatcher();
  MOZ_ASSERT(dispatcher);

  auto checkForEachPseudo = [&](PseudoStyleRequest&& aRequest) {
    return CheckForActiveAnimationsForEachPseudo(*root, *timeline, *dispatcher,
                                                 std::move(aRequest));
  };

  bool hasActiveAnimations =
      checkForEachPseudo(PseudoStyleRequest(PseudoStyleType::ViewTransition));
  for (nsAtom* name : mNamedElements.Keys()) {
    if (hasActiveAnimations) {
      break;
    }

    hasActiveAnimations =
        checkForEachPseudo({PseudoStyleType::ViewTransitionGroup, name}) ||
        checkForEachPseudo({PseudoStyleType::ViewTransitionImagePair, name}) ||
        checkForEachPseudo({PseudoStyleType::ViewTransitionOld, name}) ||
        checkForEachPseudo({PseudoStyleType::ViewTransitionNew, name});
  }
  return hasActiveAnimations;
}

void ViewTransition::ClearNamedElements() {
  for (auto& entry : mNamedElements) {
    if (auto* element = entry.GetData()->mNewElement.get()) {
      if (nsIFrame* f = element->GetPrimaryFrame()) {
        SetCaptured(f, false, nullptr);
      }
    }
  }
  mNamedElements.Clear();
  mNames.Clear();
}

static void ClearViewTransitionsAnimationData(Element* aRoot) {
  if (!aRoot) {
    return;
  }

  auto* data = aRoot->GetAnimationData();
  if (!data) {
    return;
  }
  data->ClearViewTransitionPseudos();
}

// https://drafts.csswg.org/css-view-transitions-1/#clear-view-transition
void ViewTransition::ClearActiveTransition(bool aIsDocumentHidden) {
  // Steps 1-2
  MOZ_ASSERT(mDocument);
  MOZ_ASSERT(mDocument->GetActiveViewTransition() == this);

  // Ensure that any styles associated with :active-view-transition no longer
  // apply.
  if (auto* root = mDocument->GetRootElement()) {
    root->RemoveStates(ElementState::ACTIVE_VIEW_TRANSITION);
  }

  // Step 3
  ClearNamedElements();

  // Step 4: Clear show transition tree flag (we just destroy the pseudo tree,
  // see SetupTransitionPseudoElements).
  if (mSnapshotContainingBlock) {
    nsAutoScriptBlocker scriptBlocker;
    if (mDocument->DevToolsAnonymousAndShadowEventsEnabled()) {
      mSnapshotContainingBlock->QueueDevtoolsAnonymousEvent(
          /* aIsRemove = */ true);
    }
    if (PresShell* ps = mDocument->GetPresShell()) {
      ps->ContentWillBeRemoved(mSnapshotContainingBlock, {});
    }
    mSnapshotContainingBlock->UnbindFromTree();
    mSnapshotContainingBlock = nullptr;

    // If the document is being destroyed, we cannot get the animation data
    // (e.g. it may crash when using nsINode::GetBoolFlag()), so we have to skip
    // this case. It's fine because those animations should still be stopped and
    // removed if no frame there.
    //
    // Another case is that the document is hidden. In that case, we don't setup
    // the pseudo elements, so it's fine to skip it as well.
    if (!aIsDocumentHidden) {
      ClearViewTransitionsAnimationData(mDocument->GetRootElement());
    }
  }
  mDocument->ClearActiveViewTransition();
}

void ViewTransition::SkipTransition(SkipTransitionReason aReason) {
  SkipTransition(aReason, JS::UndefinedHandleValue);
}

// https://drafts.csswg.org/css-view-transitions-1/#skip-the-view-transition
// https://drafts.csswg.org/css-view-transitions-1/#dom-viewtransition-skiptransition
void ViewTransition::SkipTransition(
    SkipTransitionReason aReason,
    JS::Handle<JS::Value> aUpdateCallbackRejectReason) {
  MOZ_ASSERT(mDocument);
  MOZ_ASSERT_IF(aReason != SkipTransitionReason::JS, mPhase != Phase::Done);
  MOZ_ASSERT_IF(aReason != SkipTransitionReason::UpdateCallbackRejected,
                aUpdateCallbackRejectReason == JS::UndefinedHandleValue);
  VT_LOG("ViewTransition::SkipTransition(%d, %d)\n", int(mPhase), int(aReason));
  AUTO_PROFILER_TERMINATING_FLOW_MARKER("ViewTransition::SkipTransition",
                                        LAYOUT, Flow::FromPointer(this));
  if (mPhase == Phase::Done) {
    return;
  }
  // Step 3: If transition’s phase is before "update-callback-called", then
  // schedule the update callback for transition.
  if (UnderlyingValue(mPhase) < UnderlyingValue(Phase::UpdateCallbackCalled)) {
    mDocument->ScheduleViewTransitionUpdateCallback(this);
  }

  // Step 4: Set rendering suppression for view transitions to false.
  mDocument->SetRenderingSuppressedForViewTransitions(false);

  // Step 5: If document's active view transition is transition, Clear view
  // transition transition.
  if (mDocument->GetActiveViewTransition() == this) {
    ClearActiveTransition(aReason == SkipTransitionReason::DocumentHidden);
  }

  // Step 6: Set transition's phase to "done".
  mPhase = Phase::Done;

  // Step 7: Reject transition's ready promise with reason.
  Promise* ucd = GetUpdateCallbackDone(IgnoreErrors());
  if (Promise* readyPromise = GetReady(IgnoreErrors())) {
    switch (aReason) {
      case SkipTransitionReason::JS:
        readyPromise->MaybeRejectWithAbortError(
            "Skipped ViewTransition due to skipTransition() call");
        break;
      case SkipTransitionReason::ClobberedActiveTransition:
        readyPromise->MaybeRejectWithAbortError(
            "Skipped ViewTransition due to another transition starting");
        break;
      case SkipTransitionReason::DocumentHidden:
        readyPromise->MaybeRejectWithInvalidStateError(
            "Skipped ViewTransition due to document being hidden");
        break;
      case SkipTransitionReason::Timeout:
        readyPromise->MaybeRejectWithTimeoutError(
            "Skipped ViewTransition due to timeout");
        break;
      case SkipTransitionReason::DuplicateTransitionNameCapturingOldState:
        readyPromise->MaybeRejectWithInvalidStateError(
            "Duplicate view-transition-name value while capturing old state");
        break;
      case SkipTransitionReason::DuplicateTransitionNameCapturingNewState:
        readyPromise->MaybeRejectWithInvalidStateError(
            "Duplicate view-transition-name value while capturing new state");
        break;
      case SkipTransitionReason::RootRemoved:
        readyPromise->MaybeRejectWithInvalidStateError(
            "Skipped view transition due to root element going away");
        break;
      case SkipTransitionReason::PageSwap:
        readyPromise->MaybeRejectWithInvalidStateError(
            "Skipped view transition due to page swap");
        break;
      case SkipTransitionReason::Resize:
        readyPromise->MaybeRejectWithInvalidStateError(
            "Skipped view transition due to viewport resize");
        break;
      case SkipTransitionReason::PseudoUpdateFailure:
        readyPromise->MaybeRejectWithInvalidStateError(
            "Skipped view transition due to hidden new element");
        break;
      case SkipTransitionReason::ResetRendering:
        readyPromise->MaybeRejectWithInvalidStateError(
            "Skipped view transition due to graphics process or device reset");
        break;
      case SkipTransitionReason::UpdateCallbackRejected:
        readyPromise->MaybeReject(aUpdateCallbackRejectReason);

        // Step 8, The case we have to reject the finished promise. Do this here
        // to make sure it reacts to UpdateCallbackRejected.
        //
        // Note: we intentionally reject the finished promise after the ready
        // promise to make sure the order of promise callbacks is correct in
        // script.
        if (ucd) {
          MOZ_ASSERT(ucd->State() == Promise::PromiseState::Rejected);
          if (Promise* finished = GetFinished(IgnoreErrors())) {
            // Since the rejection of transition’s update callback done promise
            // isn’t explicitly handled here, if transition’s update callback
            // done promise rejects, then transition’s finished promise will
            // reject with the same reason.
            finished->MaybeReject(aUpdateCallbackRejectReason);
          }
        }
        break;
    }
  }

  // Step 8: Resolve transition's finished promise with the result of reacting
  // to transition's update callback done promise:
  // Note: It is not guaranteed that |mPhase| is Done in CallUpdateCallback().
  // There are two possible cases:
  // 1. If we skip the view transitions before updateCallbackDone callback
  //    is dispatched, we come here first. In this case we don't have to resolve
  //    the finsihed promise because CallUpdateCallback() will do it.
  // 2. If we skip the view transitions after updateCallbackDone callback, the
  //    finished promise hasn't been resolved because |mPhase| is not Done (i.e.
  //    |mPhase| is UpdateCallbackCalled) when we handle updateCallbackDone
  //    callback. Therefore, we have to resolve the finished promise based on
  //    the PromiseState of |mUpdateCallbackDone|.
  if (ucd && ucd->State() == Promise::PromiseState::Resolved) {
    if (Promise* finished = GetFinished(IgnoreErrors())) {
      // If the promise was fulfilled, then return undefined.
      finished->MaybeResolveWithUndefined();
    }
  }
}

Maybe<uint64_t> ViewTransition::GetElementIdentifier(Element* aElement) const {
  return mElementIdentifiers.MaybeGet(aElement);
}

uint64_t ViewTransition::EnsureElementIdentifier(Element* aElement) {
  static uint64_t sLastIdentifier = 0;
  return mElementIdentifiers.WithEntryHandle(aElement, [&](auto&& entry) {
    return entry.OrInsertWith([&]() { return sLastIdentifier++; });
  });
}

already_AddRefed<nsAtom> ViewTransition::DocumentScopedTransitionNameFor(
    nsIFrame* aFrame) {
  // TODO(emilio): Bug 1970954. These aren't quite correct, per spec we're
  // supposed to only honor names and classes coming from the document, but
  // that's quite some magic, and it's getting actively discussed, see:
  // https://github.com/w3c/csswg-drafts/issues/10808 and related
  // https://drafts.csswg.org/css-view-transitions-1/#document-scoped-view-transition-name
  // https://drafts.csswg.org/css-view-transitions-2/#additions-to-vt-name
  // 1. Let computed be the computed value of view-transition-name.
  const auto& computed = aFrame->StyleUIReset()->mViewTransitionName;
  nsAtom* ident = computed.value.AsAtom();

  // 2. If computed is none, return null.
  if (ident == nsGkAtoms::none) {
    return nullptr;
  }

  // As a special case, if we're a <table> element, the table wrapper is what's
  // captured.
  if (aFrame->IsTableFrame()) {
    return nullptr;
  }

  // If the name is not associated with the document, return null.
  // https://drafts.csswg.org/css-view-transitions-1/#document-scoped-view-transition-name
  nsIContent* content = aFrame->GetContent();
  if (MOZ_UNLIKELY(!content) ||
      AnchorPositioningUtils::GetShadowRootForTreeScope(*content->AsElement(),
                                                        computed.scope)) {
    return nullptr;
  }

  // 3. If computed is a <custom-ident>, return computed.
  if (ident != nsGkAtoms::match_element) {
    return do_AddRef(ident);
  }

  // 4. Assert: computed is auto or match-element.
  // TODO: Bug 1918218. Implement auto or others, depending on the spec issue.
  // https://github.com/w3c/csswg-drafts/issues/12091
  // 5. If computed is auto, element has an associated id, and computed is
  // associated with the same root as element’s root, then return a unique
  // string starting with "-ua-". Two elements with the same id must return the
  // same string, regardless of their node document.
  // TODO: Bug 1918218. auto keyword may be changed. See the spec issue
  // mentioned above..

  // 6. Return a unique string starting with "-ua-". The string should remain
  // consistent and unique for this element and Document, at least for the
  // lifetime of element’s node document’s active view transition.
  if (MOZ_UNLIKELY(!content->IsElement())) {
    return nullptr;
  }

  uint64_t id = EnsureElementIdentifier(content->AsElement());

  // FIXME: We may have to revist here when working on cross document because we
  // may have to return a warning and nullptr, per the comment in the design
  // review.
  // https://github.com/w3ctag/design-reviews/issues/1001#issuecomment-2750966335
  nsCString name;
  // Note: Add the "view-transition-name" in the prefix so we know this is for
  // auto-generated view-transition-name.
  name.AppendLiteral("-ua-view-transition-name-");
  name.AppendInt(id);
  return NS_Atomize(name);
}

JSObject* ViewTransition::WrapObject(JSContext* aCx,
                                     JS::Handle<JSObject*> aGivenProto) {
  return ViewTransition_Binding::Wrap(aCx, this, aGivenProto);
}

static void ComputeActiveRect1D(nscoord aViewMin, nscoord aViewSize,
                                nscoord& aCaptureMin, nscoord& aCaptureSize) {
  nscoord captureMax = aCaptureMin + aCaptureSize;
  nscoord viewMax = aViewMin + aViewSize;

  nscoord min;
  nscoord max;

  if (aCaptureSize < aViewSize) {
    // The snapshot area is small enough on this axis, don't clip it.
    min = aCaptureMin;
    max = min + aCaptureSize;
  } else if (aViewMin < aCaptureMin) {
    // The view is before the capture area. Restrict the cpature size while
    // snaping it to the beginning of its range.
    min = aCaptureMin;
    max = min + aViewSize;
  } else if (viewMax > captureMax) {
    // The view is after the capture area. Restrict the cpature size while
    // snaping it to the end of its range.
    max = captureMax;
    min = max - aViewSize;
  } else {
    // The snapshot area extends beyond the viewport on both sides,
    // set it to the viewport.
    min = aViewMin;
    max = viewMax;
  }

  aCaptureMin = min;
  aCaptureSize = max - min;
}

void ViewTransition::UpdateActiveRectForCapturedFrame(
    nsIFrame* aCapturedFrame, const gfx::MatrixScales& aInheritedScale,
    nsRect& aOutCaptureRect) {
  nsAtom* name = aCapturedFrame->GetProperty(ViewTransitionCaptureName());
  if (NS_WARN_IF(!name)) {
    return;
  }

  auto* el = mNamedElements.Get(name);
  if (NS_WARN_IF(!el)) {
    return;
  }

  const bool isOld = mPhase < Phase::Animating;

  // The active rect to update (old or new).
  Maybe<nsRect>* activeRect;
  if (isOld) {
    activeRect = &el->mOldActiveRect;
    // We don't rely on it, but as a sanity check, since we only capture
    // the old state once so we aren't expecting it to already contain an
    // active rect.
    MOZ_ASSERT(activeRect->isNothing());
  } else {
    activeRect = &el->mNewActiveRect;
  }

  // Reset the active rect in case we early out and had previously
  // updated it.
  activeRect->reset();

  auto presShell = aCapturedFrame->PresShell();
  if (!presShell->IsVisualViewportSizeSet()) {
    return;
  }

  nsPresContext* pc = aCapturedFrame->PresContext();

  auto rootViewportSize = presShell->GetVisualViewportSize();
  auto auPerDevPx = pc->AppUnitsPerDevPixel();
  auto vvpSize = LayoutDeviceSize::FromAppUnits(rootViewportSize, auPerDevPx);
  auto capSize =
      LayoutDeviceSize::FromAppUnits(aOutCaptureRect.Size(), auPerDevPx);
  capSize.width *= aInheritedScale.xScale;
  capSize.height *= aInheritedScale.yScale;

  // If the capture size is smaller than the visual viewport, it's a good
  // indication that it is not unreasonably large, so we can early out.
  if (capSize.width < vvpSize.width && capSize.height < vvpSize.height) {
    return;
  }

  // viewport is relative to the root frame.
  // auto rootViewportOrigin = presShell->GetVisualViewportOffset();
  auto rootViewportOrigin = nsPoint(0, 0);
  nsRect viewport = nsRect(rootViewportOrigin, rootViewportSize);

  // Inflate the viewport rect to give a bit of extra headroom in case the user
  // scrolls a bit during the transition or the transition has some motion to
  // it. But at the same time we want to avoid the margin pushing the snapshot
  // size over 4k pixels since that will cause WebRender to render it
  // downscaled.
  float scale = std::max(aInheritedScale.xScale, aInheritedScale.yScale);
  nscoord margin = NSFloatPixelsToAppUnits(512.0 / scale, auPerDevPx);
  nscoord maxSize = NSFloatPixelsToAppUnits(4096.0 / scale, auPerDevPx);
  margin = std::min(
      margin,
      std::max(0, maxSize - std::max(viewport.width, viewport.height)) / 2);

  viewport.Inflate(margin);

  nsIFrame* rootFrame = pc->GetPresShell()->GetRootFrame();

  const auto SUCCESS = nsLayoutUtils::TransformResult::TRANSFORM_SUCCEEDED;
  if (!rootFrame || nsLayoutUtils::TransformRect(rootFrame, aCapturedFrame,
                                                 viewport) != SUCCESS) {
    return;
  }
  // viewport is now relative to aCapturedFrame.

  ComputeActiveRect1D(viewport.x, viewport.width, aOutCaptureRect.x,
                      aOutCaptureRect.width);
  ComputeActiveRect1D(viewport.y, viewport.height, aOutCaptureRect.y,
                      aOutCaptureRect.height);

  // Store the active rect for later when we create the image items.
  *activeRect = Some(aOutCaptureRect);
}

Maybe<nsRect> ViewTransition::GetOldActiveRect(nsAtom* aName) const {
  auto* el = mNamedElements.Get(aName);
  if (NS_WARN_IF(!el)) {
    return Nothing();
  }

  return el->mOldActiveRect;
}

Maybe<nsRect> ViewTransition::GetNewActiveRect(nsAtom* aName) const {
  auto* el = mNamedElements.Get(aName);
  if (NS_WARN_IF(!el)) {
    return Nothing();
  }

  return el->mNewActiveRect;
}

ViewTransitionTypeSet* ViewTransition::Types() {
  if (!mTypes) {
    mTypes = new ViewTransitionTypeSet(*this);
    for (const auto& type : mTypeList) {
      ViewTransitionTypeSet_Binding::SetlikeHelpers::Add(
          mTypes, nsDependentAtomString(type), IgnoreErrors());
    }
  }
  return mTypes;
}

};  // namespace mozilla::dom