1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "platform/animation/CompositorAnimation.h"
#include "base/memory/ptr_util.h"
#include "cc/animation/animation_curve.h"
#include "cc/animation/animation_id_provider.h"
#include "cc/animation/keyframed_animation_curve.h"
#include "platform/animation/CompositorAnimationCurve.h"
#include "platform/animation/CompositorFilterAnimationCurve.h"
#include "platform/animation/CompositorFloatAnimationCurve.h"
#include "platform/animation/CompositorScrollOffsetAnimationCurve.h"
#include "platform/animation/CompositorTransformAnimationCurve.h"
#include <memory>
using cc::Animation;
using cc::AnimationIdProvider;
using blink::CompositorAnimation;
using blink::CompositorAnimationCurve;
namespace blink {
CompositorAnimation::CompositorAnimation(
const CompositorAnimationCurve& curve,
CompositorTargetProperty::Type targetProperty,
int animationId,
int groupId) {
if (!animationId)
animationId = AnimationIdProvider::NextAnimationId();
if (!groupId)
groupId = AnimationIdProvider::NextGroupId();
m_animation = Animation::Create(curve.cloneToAnimationCurve(), animationId,
groupId, targetProperty);
}
CompositorAnimation::~CompositorAnimation() {}
int CompositorAnimation::id() const {
return m_animation->id();
}
int CompositorAnimation::group() const {
return m_animation->group();
}
CompositorTargetProperty::Type CompositorAnimation::targetProperty() const {
return m_animation->target_property();
}
double CompositorAnimation::iterations() const {
return m_animation->iterations();
}
void CompositorAnimation::setIterations(double n) {
m_animation->set_iterations(n);
}
double CompositorAnimation::iterationStart() const {
return m_animation->iteration_start();
}
void CompositorAnimation::setIterationStart(double iterationStart) {
m_animation->set_iteration_start(iterationStart);
}
double CompositorAnimation::startTime() const {
return (m_animation->start_time() - base::TimeTicks()).InSecondsF();
}
void CompositorAnimation::setStartTime(double monotonicTime) {
m_animation->set_start_time(base::TimeTicks::FromInternalValue(
monotonicTime * base::Time::kMicrosecondsPerSecond));
}
double CompositorAnimation::timeOffset() const {
return m_animation->time_offset().InSecondsF();
}
void CompositorAnimation::setTimeOffset(double monotonicTime) {
m_animation->set_time_offset(base::TimeDelta::FromSecondsD(monotonicTime));
}
blink::CompositorAnimation::Direction CompositorAnimation::getDirection()
const {
return m_animation->direction();
}
void CompositorAnimation::setDirection(Direction direction) {
m_animation->set_direction(direction);
}
double CompositorAnimation::playbackRate() const {
return m_animation->playback_rate();
}
void CompositorAnimation::setPlaybackRate(double playbackRate) {
m_animation->set_playback_rate(playbackRate);
}
blink::CompositorAnimation::FillMode CompositorAnimation::getFillMode() const {
return m_animation->fill_mode();
}
void CompositorAnimation::setFillMode(FillMode fillMode) {
m_animation->set_fill_mode(fillMode);
}
std::unique_ptr<cc::Animation> CompositorAnimation::releaseCcAnimation() {
m_animation->set_needs_synchronized_start_time(true);
return std::move(m_animation);
}
std::unique_ptr<CompositorFloatAnimationCurve>
CompositorAnimation::floatCurveForTesting() const {
const cc::AnimationCurve* curve = m_animation->curve();
DCHECK_EQ(cc::AnimationCurve::FLOAT, curve->Type());
auto keyframedCurve = base::WrapUnique(
static_cast<cc::KeyframedFloatAnimationCurve*>(curve->Clone().release()));
return CompositorFloatAnimationCurve::createForTesting(
std::move(keyframedCurve));
}
} // namespace blink
|
