chromium/cc/animation/animation.cc

// Copyright 2015 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/animation.h"

#include <inttypes.h>
#include <algorithm>
#include <memory>
#include <string>
#include <utility>

#include "base/strings/stringprintf.h"
#include "cc/animation/animation_delegate.h"
#include "cc/animation/animation_events.h"
#include "cc/animation/animation_host.h"
#include "cc/animation/animation_timeline.h"
#include "cc/animation/keyframe_effect.h"
#include "cc/animation/scroll_offset_animation_curve.h"
#include "cc/animation/scroll_timeline.h"
#include "cc/trees/property_animation_state.h"

namespace cc {

scoped_refptr<Animation> Animation::Create(int id) { … }

Animation::Animation(int id) : … { … }

Animation::~Animation() { … }

scoped_refptr<Animation> Animation::CreateImplInstance() const { … }

ElementId Animation::element_id() const { … }

void Animation::SetAnimationHost(AnimationHost* animation_host) { … }

void Animation::SetAnimationTimeline(AnimationTimeline* timeline) { … }

scoped_refptr<const ElementAnimations> Animation::element_animations() const { … }

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

void Animation::AttachPaintWorkletElement() { … }

void Animation::AttachElementInternal(ElementId element_id) { … }

void Animation::SetKeyframeEffectForTesting(
    std::unique_ptr<KeyframeEffect> effect) { … }

bool Animation::IsOwnerThread() const { … }

bool Animation::InProtectedSequence() const { … }

void Animation::WaitForProtectedSequenceCompletion() const { … }

void Animation::DetachElement() { … }

void Animation::RegisterAnimation() { … }

void Animation::UnregisterAnimation() { … }

void Animation::PushPropertiesTo(Animation* animation_impl) { … }

bool Animation::Tick(base::TimeTicks tick_time) { … }

bool Animation::IsScrollLinkedAnimation() const { … }

void Animation::UpdateState(bool start_ready_animations,
                            AnimationEvents* events) { … }

void Animation::AddToTicking() { … }

void Animation::RemoveFromTicking() { … }

void Animation::DispatchAndDelegateAnimationEvent(const AnimationEvent& event) { … }

void Animation::DelegateAnimationEvent(const AnimationEvent& event) { … }

bool Animation::RequiresInvalidation() const { … }

bool Animation::AffectsNativeProperty() const { … }

void Animation::SetNeedsCommit() { … }

std::optional<base::TimeTicks> Animation::GetStartTime() const { … }

void Animation::SetNeedsPushProperties() { … }

void Animation::ActivateKeyframeModels() { … }

KeyframeModel* Animation::GetKeyframeModel(
    TargetProperty::Type target_property) const { … }

std::string Animation::ToString() const { … }

bool Animation::IsWorkletAnimation() const { … }

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

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

void Animation::RemoveKeyframeModel(int keyframe_model_id) { … }

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

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

void Animation::NotifyKeyframeModelFinishedForTesting(
    int timeline_id,
    int keyframe_model_id,
    TargetProperty::Type target_property,
    int group_id) { … }

}  // namespace cc