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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
// Copyright 2015 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.
#ifndef CC_TEST_ANIMATION_TIMELINES_TEST_COMMON_H_
#define CC_TEST_ANIMATION_TIMELINES_TEST_COMMON_H_
#include <unordered_map>
#include "base/memory/scoped_ptr.h"
#include "cc/animation/animation.h"
#include "cc/animation/animation_delegate.h"
#include "cc/animation/animation_host.h"
#include "cc/trees/mutator_host_client.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/gfx/geometry/scroll_offset.h"
namespace cc {
class TestLayer {
public:
static scoped_ptr<TestLayer> Create();
void ClearMutatedProperties();
int transform_x() const { return transform_x_; }
int transform_y() const { return transform_y_; }
void set_transform(int transform_x, int transform_y) {
transform_x_ = transform_x;
transform_y_ = transform_y;
mutated_properties_[TargetProperty::TRANSFORM] = true;
}
float opacity() const { return opacity_; }
void set_opacity(float opacity) {
opacity_ = opacity;
mutated_properties_[TargetProperty::OPACITY] = true;
}
float brightness() const { return brightness_; }
void set_brightness(float brightness) {
brightness_ = brightness;
mutated_properties_[TargetProperty::FILTER] = true;
}
gfx::ScrollOffset scroll_offset() const { return scroll_offset_; }
void set_scroll_offset(const gfx::ScrollOffset& scroll_offset) {
scroll_offset_ = scroll_offset;
mutated_properties_[TargetProperty::SCROLL_OFFSET] = true;
}
bool is_property_mutated(TargetProperty::Type property) const {
return mutated_properties_[property];
}
private:
TestLayer();
int transform_x_;
int transform_y_;
float opacity_;
float brightness_;
gfx::ScrollOffset scroll_offset_;
bool mutated_properties_[TargetProperty::LAST_TARGET_PROPERTY + 1];
};
class TestHostClient : public MutatorHostClient {
public:
explicit TestHostClient(ThreadInstance thread_instance);
~TestHostClient();
void ClearMutatedProperties();
bool IsLayerInTree(int layer_id, LayerTreeType tree_type) const override;
void SetMutatorsNeedCommit() override;
void SetMutatorsNeedRebuildPropertyTrees() override;
void SetLayerFilterMutated(int layer_id,
LayerTreeType tree_type,
const FilterOperations& filters) override;
void SetLayerOpacityMutated(int layer_id,
LayerTreeType tree_type,
float opacity) override;
void SetLayerTransformMutated(int layer_id,
LayerTreeType tree_type,
const gfx::Transform& transform) override;
void SetLayerScrollOffsetMutated(
int layer_id,
LayerTreeType tree_type,
const gfx::ScrollOffset& scroll_offset) override;
void LayerTransformIsPotentiallyAnimatingChanged(int layer_id,
LayerTreeType tree_type,
bool is_animating) override {
}
void ScrollOffsetAnimationFinished() override {}
gfx::ScrollOffset GetScrollOffsetForAnimation(int layer_id) const override;
bool mutators_need_commit() const { return mutators_need_commit_; }
void set_mutators_need_commit(bool need) { mutators_need_commit_ = need; }
void RegisterLayer(int layer_id, LayerTreeType tree_type);
void UnregisterLayer(int layer_id, LayerTreeType tree_type);
AnimationHost* host() {
DCHECK(host_);
return host_.get();
}
bool IsPropertyMutated(int layer_id,
LayerTreeType tree_type,
TargetProperty::Type property) const;
void ExpectFilterPropertyMutated(int layer_id,
LayerTreeType tree_type,
float brightness) const;
void ExpectOpacityPropertyMutated(int layer_id,
LayerTreeType tree_type,
float opacity) const;
void ExpectTransformPropertyMutated(int layer_id,
LayerTreeType tree_type,
int transform_x,
int transform_y) const;
TestLayer* FindTestLayer(int layer_id, LayerTreeType tree_type) const;
private:
scoped_ptr<AnimationHost> host_;
using LayerIdToTestLayer = std::unordered_map<int, scoped_ptr<TestLayer>>;
LayerIdToTestLayer layers_in_active_tree_;
LayerIdToTestLayer layers_in_pending_tree_;
bool mutators_need_commit_;
};
class TestAnimationDelegate : public AnimationDelegate {
public:
TestAnimationDelegate();
void NotifyAnimationStarted(base::TimeTicks monotonic_time,
TargetProperty::Type target_property,
int group) override;
void NotifyAnimationFinished(base::TimeTicks monotonic_time,
TargetProperty::Type target_property,
int group) override;
void NotifyAnimationAborted(base::TimeTicks monotonic_time,
TargetProperty::Type target_property,
int group) override {}
void NotifyAnimationTakeover(base::TimeTicks monotonic_time,
TargetProperty::Type target_property,
double animation_start_time,
scoped_ptr<AnimationCurve> curve) override {}
bool started_;
bool finished_;
};
class AnimationTimelinesTest : public testing::Test {
public:
AnimationTimelinesTest();
~AnimationTimelinesTest() override;
protected:
void SetUp() override;
void TearDown() override;
void GetImplTimelineAndPlayerByID();
void ReleaseRefPtrs();
void AnimateLayersTransferEvents(base::TimeTicks time,
unsigned expect_events);
AnimationPlayer* GetPlayerForLayerId(int layer_id);
AnimationPlayer* GetImplPlayerForLayerId(int layer_id);
int NextTestLayerId();
TestHostClient client_;
TestHostClient client_impl_;
AnimationHost* host_;
AnimationHost* host_impl_;
const int timeline_id_;
const int player_id_;
int layer_id_;
int next_test_layer_id_;
scoped_refptr<AnimationTimeline> timeline_;
scoped_refptr<AnimationPlayer> player_;
scoped_refptr<AnimationTimeline> timeline_impl_;
scoped_refptr<AnimationPlayer> player_impl_;
};
} // namespace cc
#endif // CC_TEST_ANIMATION_TIMELINES_TEST_COMMON_H_
|
