keyframe_effect.cc | Explore in Territory

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

#include "cc/animation/keyframe_effect.h"

#include <algorithm>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "base/notreached.h"
#include "base/ranges/algorithm.h"
#include "base/time/time.h"
#include "cc/animation/animation.h"
#include "cc/animation/animation_host.h"
#include "cc/animation/animation_timeline.h"
#include "cc/animation/scroll_offset_animation_curve.h"
#include "cc/base/features.h"
#include "cc/trees/property_animation_state.h"
#include "ui/gfx/animation/keyframe/animation_curve.h"
#include "ui/gfx/animation/keyframe/target_property.h"
#include "ui/gfx/geometry/transform_operations.h"
#include "ui/gfx/geometry/vector2d_f.h"

namespace cc {

namespace {

bool NeedsFinishedEvent(KeyframeModel* keyframe_model) { … }

// Returns indices for keyframe_models that have matching group id.
std::vector<size_t> FindAnimationsWithSameGroupId(
    const std::vector<std::unique_ptr<gfx::KeyframeModel>>& keyframe_models,
    int group_id) { … }

}  // namespace

KeyframeEffect::KeyframeEffect(Animation* animation)
    : … { … }

KeyframeEffect::~KeyframeEffect() { … }

void KeyframeEffect::SetNeedsPushProperties() { … }

void KeyframeEffect::BindElementAnimations(
    ElementAnimations* element_animations) { … }

void KeyframeEffect::UnbindElementAnimations() { … }

void KeyframeEffect::AttachElement(ElementId element_id) { … }

void KeyframeEffect::DetachElement() { … }

bool KeyframeEffect::Tick(base::TimeTicks monotonic_time) { … }

void KeyframeEffect::RemoveFromTicking() { … }

void KeyframeEffect::UpdateState(bool start_ready_keyframe_models,
                                 AnimationEvents* events) { … }

void KeyframeEffect::UpdateTickingState() { … }

void KeyframeEffect::Pause(base::TimeTicks timeline_time,
                           PauseCondition pause_condition) { … }

void KeyframeEffect::AddKeyframeModel(
    std::unique_ptr<gfx::KeyframeModel> keyframe_model) { … }

void KeyframeEffect::PauseKeyframeModel(int keyframe_model_id,
                                        base::TimeDelta time_offset) { … }

void KeyframeEffect::AbortKeyframeModel(int keyframe_model_id) { … }

void KeyframeEffect::AbortKeyframeModelsWithProperty(
    TargetProperty::Type target_property,
    bool needs_completion) { … }

void KeyframeEffect::ActivateKeyframeModels() { … }

void KeyframeEffect::KeyframeModelAdded() { … }

bool KeyframeEffect::DispatchAnimationEventToKeyframeModel(
    const AnimationEvent& event) { … }

bool KeyframeEffect::HasTickingKeyframeModel() const { … }

bool KeyframeEffect::RequiresInvalidation() const { … }

bool KeyframeEffect::AffectsNativeProperty() const { … }

bool KeyframeEffect::AnimationsPreserveAxisAlignment() const { … }

float KeyframeEffect::MaximumScale(ElementId element_id,
                                   ElementListType list_type) const { … }

bool KeyframeEffect::IsPotentiallyAnimatingProperty(
    TargetProperty::Type target_property,
    ElementListType list_type) const { … }

bool KeyframeEffect::IsCurrentlyAnimatingProperty(
    TargetProperty::Type target_property,
    ElementListType list_type) const { … }

void KeyframeEffect::GetPropertyAnimationState(
    PropertyAnimationState* pending_state,
    PropertyAnimationState* active_state) const { … }

void KeyframeEffect::MarkAbortedKeyframeModelsForDeletion(
    KeyframeEffect* keyframe_effect_impl) { … }

void KeyframeEffect::PurgeKeyframeModelsMarkedForDeletion(bool impl_only) { … }

void KeyframeEffect::PurgeDeletedKeyframeModels() { … }

void KeyframeEffect::PushNewKeyframeModelsToImplThread(
    KeyframeEffect* keyframe_effect_impl) const { … }

namespace {
bool IsCompleted(gfx::KeyframeModel* keyframe_model,
                 const KeyframeEffect* main_thread_keyframe_effect) { … }
}  // namespace

void KeyframeEffect::RemoveKeyframeModelsCompletedOnMainThread(
    KeyframeEffect* keyframe_effect_impl) const { … }

void KeyframeEffect::PushPropertiesTo(
    KeyframeEffect* keyframe_effect_impl,
    std::optional<base::TimeTicks> replaced_start_time) { … }

std::string KeyframeEffect::KeyframeModelsToString() const { … }

base::TimeDelta KeyframeEffect::MinimumTickInterval() const { … }

void KeyframeEffect::RemoveKeyframeModelRange(
    typename KeyframeModels::iterator to_remove_begin,
    typename KeyframeModels::iterator to_remove_end) { … }

void KeyframeEffect::StartKeyframeModels(base::TimeTicks monotonic_time) { … }

void KeyframeEffect::PromoteStartedKeyframeModels(AnimationEvents* events) { … }

void KeyframeEffect::MarkKeyframeModelsForDeletion(
    base::TimeTicks monotonic_time,
    AnimationEvents* events) { … }

void KeyframeEffect::MarkFinishedKeyframeModels(
    base::TimeTicks monotonic_time) { … }

std::optional<gfx::PointF> KeyframeEffect::ScrollOffsetForAnimation() const { … }

void KeyframeEffect::GenerateEvent(AnimationEvents* events,
                                   const KeyframeModel& keyframe_model,
                                   AnimationEvent::Type type,
                                   base::TimeTicks monotonic_time) { … }

void KeyframeEffect::GenerateTakeoverEventForScrollAnimation(
    AnimationEvents* events,
    const KeyframeModel& keyframe_model,
    base::TimeTicks monotonic_time) { … }

}  // namespace cc
chromium/cc/animation/keyframe_effect.cc
