chromium/third_party/blink/renderer/core/animation/timing_calculations.cc

// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/core/animation/timing_calculations.h"

#include "base/metrics/histogram_macros.h"

namespace blink {

namespace {

inline bool EndsOnIterationBoundary(double iteration_count,
                                    double iteration_start) { … }

void RecordBoundaryMisalignment(AnimationTimeDelta misalignment) { … }

}  // namespace

double TimingCalculations::TimingCalculationEpsilon() { … }

AnimationTimeDelta TimingCalculations::TimeTolerance() { … }

bool TimingCalculations::IsWithinAnimationTimeEpsilon(double a, double b) { … }

bool TimingCalculations::IsWithinAnimationTimeTolerance(AnimationTimeDelta a,
                                                        AnimationTimeDelta b) { … }

bool TimingCalculations::LessThanOrEqualToWithinEpsilon(double a, double b) { … }

bool TimingCalculations::LessThanOrEqualToWithinTimeTolerance(
    AnimationTimeDelta a,
    AnimationTimeDelta b) { … }

bool TimingCalculations::GreaterThanOrEqualToWithinEpsilon(double a, double b) { … }

bool TimingCalculations::GreaterThanOrEqualToWithinTimeTolerance(
    AnimationTimeDelta a,
    AnimationTimeDelta b) { … }

bool TimingCalculations::GreaterThanWithinTimeTolerance(AnimationTimeDelta a,
                                                        AnimationTimeDelta b) { … }

double TimingCalculations::MultiplyZeroAlwaysGivesZero(double x, double y) { … }

AnimationTimeDelta TimingCalculations::MultiplyZeroAlwaysGivesZero(
    AnimationTimeDelta x,
    double y) { … }

// https://w3.org/TR/web-animations-1/#animation-effect-phases-and-states
Timing::Phase TimingCalculations::CalculatePhase(
    const Timing::NormalizedTiming& normalized,
    std::optional<AnimationTimeDelta>& local_time,
    Timing::AnimationDirection direction) { … }

// https://w3.org/TR/web-animations-1/#calculating-the-active-time
std::optional<AnimationTimeDelta> TimingCalculations::CalculateActiveTime(
    const Timing::NormalizedTiming& normalized,
    Timing::FillMode fill_mode,
    std::optional<AnimationTimeDelta> local_time,
    Timing::Phase phase) { … }

// Calculates the overall progress, which describes the number of iterations
// that have completed (including partial iterations).
// https://w3.org/TR/web-animations-1/#calculating-the-overall-progress
std::optional<double> TimingCalculations::CalculateOverallProgress(
    Timing::Phase phase,
    std::optional<AnimationTimeDelta> active_time,
    AnimationTimeDelta iteration_duration,
    double iteration_count,
    double iteration_start) { … }

// Calculates the simple iteration progress, which is a fraction of the progress
// through the current iteration that ignores transformations to the time
// introduced by the playback direction or timing functions applied to the
// effect.
// https://w3.org/TR/web-animations-1/#calculating-the-simple-iteration-progress
std::optional<double> TimingCalculations::CalculateSimpleIterationProgress(
    Timing::Phase phase,
    std::optional<double> overall_progress,
    double iteration_start,
    std::optional<AnimationTimeDelta> active_time,
    AnimationTimeDelta active_duration,
    double iteration_count) { … }

// https://w3.org/TR/web-animations-1/#calculating-the-current-iteration
std::optional<double> TimingCalculations::CalculateCurrentIteration(
    Timing::Phase phase,
    std::optional<AnimationTimeDelta> active_time,
    double iteration_count,
    std::optional<double> overall_progress,
    std::optional<double> simple_iteration_progress) { … }

// https://w3.org/TR/web-animations-1/#calculating-the-directed-progress
bool TimingCalculations::IsCurrentDirectionForwards(
    std::optional<double> current_iteration,
    Timing::PlaybackDirection direction) { … }

// https://w3.org/TR/web-animations-1/#calculating-the-directed-progress
std::optional<double> TimingCalculations::CalculateDirectedProgress(
    std::optional<double> simple_iteration_progress,
    std::optional<double> current_iteration,
    Timing::PlaybackDirection direction) { … }

// https://w3.org/TR/web-animations-1/#calculating-the-transformed-progress
std::optional<double> TimingCalculations::CalculateTransformedProgress(
    Timing::Phase phase,
    std::optional<double> directed_progress,
    bool is_current_direction_forward,
    scoped_refptr<TimingFunction> timing_function) { … }

// Offsets the active time by how far into the animation we start (i.e. the
// product of the iteration start and iteration duration). This is not part of
// the Web Animations spec; it is used for calculating the time until the next
// iteration to optimize scheduling.
std::optional<AnimationTimeDelta> TimingCalculations::CalculateOffsetActiveTime(
    AnimationTimeDelta active_duration,
    std::optional<AnimationTimeDelta> active_time,
    AnimationTimeDelta start_offset) { … }

// Maps the offset active time into 'iteration time space'[0], aka the offset
// into the current iteration. This is not part of the Web Animations spec (note
// that the section linked below is non-normative); it is used for calculating
// the time until the next iteration to optimize scheduling.
//
// [0] https://w3.org/TR/web-animations-1/#iteration-time-space
std::optional<AnimationTimeDelta> TimingCalculations::CalculateIterationTime(
    AnimationTimeDelta iteration_duration,
    AnimationTimeDelta active_duration,
    std::optional<AnimationTimeDelta> offset_active_time,
    AnimationTimeDelta start_offset,
    Timing::Phase phase,
    const Timing& specified) { … }

}  // namespace blink