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
|
// Copyright 2012 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_LAYER_TEST_COMMON_H_
#define CC_TEST_LAYER_TEST_COMMON_H_
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "cc/quads/render_pass.h"
#include "cc/test/fake_layer_tree_host.h"
#include "cc/test/test_task_graph_runner.h"
#include "cc/trees/layer_tree_host_impl.h"
#define EXPECT_SET_NEEDS_COMMIT(expect, code_to_test) \
do { \
EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times((expect)); \
code_to_test; \
Mock::VerifyAndClearExpectations(layer_tree_host_.get()); \
} while (false)
#define EXPECT_SET_NEEDS_UPDATE(expect, code_to_test) \
do { \
EXPECT_CALL(*layer_tree_host_, SetNeedsUpdateLayers()).Times((expect)); \
code_to_test; \
Mock::VerifyAndClearExpectations(layer_tree_host_.get()); \
} while (false)
namespace gfx { class Rect; }
namespace cc {
class LayerImpl;
class OutputSurface;
class QuadList;
class RenderSurfaceImpl;
class ResourceProvider;
class LayerTestCommon {
public:
static const char* quad_string;
static void VerifyQuadsExactlyCoverRect(const QuadList& quads,
const gfx::Rect& rect);
static void VerifyQuadsAreOccluded(const QuadList& quads,
const gfx::Rect& occluded,
size_t* partially_occluded_count);
class LayerImplTest {
public:
LayerImplTest();
explicit LayerImplTest(const LayerTreeSettings& settings);
~LayerImplTest();
template <typename T>
T* AddChildToRoot() {
scoped_ptr<T> layer =
T::Create(host_->host_impl()->active_tree(), layer_impl_id_++);
T* ptr = layer.get();
root_layer_impl_->AddChild(layer.Pass());
return ptr;
}
template <typename T>
T* AddChild(LayerImpl* parent) {
scoped_ptr<T> layer =
T::Create(host_->host_impl()->active_tree(), layer_impl_id_++);
T* ptr = layer.get();
parent->AddChild(layer.Pass());
return ptr;
}
template <typename T, typename A>
T* AddChildToRoot(const A& a) {
scoped_ptr<T> layer =
T::Create(host_->host_impl()->active_tree(), layer_impl_id_++, a);
T* ptr = layer.get();
root_layer_impl_->AddChild(layer.Pass());
return ptr;
}
template <typename T, typename A, typename B>
T* AddChildToRoot(const A& a, const B& b) {
scoped_ptr<T> layer =
T::Create(host_->host_impl()->active_tree(), layer_impl_id_++, a, b);
T* ptr = layer.get();
root_layer_impl_->AddChild(layer.Pass());
return ptr;
}
template <typename T, typename A, typename B, typename C, typename D>
T* AddChildToRoot(const A& a, const B& b, const C& c, const D& d) {
scoped_ptr<T> layer = T::Create(host_->host_impl()->active_tree(),
layer_impl_id_++, a, b, c, d);
T* ptr = layer.get();
root_layer_impl_->AddChild(layer.Pass());
return ptr;
}
template <typename T,
typename A,
typename B,
typename C,
typename D,
typename E>
T* AddChildToRoot(const A& a,
const B& b,
const C& c,
const D& d,
const E& e) {
scoped_ptr<T> layer = T::Create(host_->host_impl()->active_tree(),
layer_impl_id_++, a, b, c, d, e);
T* ptr = layer.get();
root_layer_impl_->AddChild(layer.Pass());
return ptr;
}
void CalcDrawProps(const gfx::Size& viewport_size);
void AppendQuadsWithOcclusion(LayerImpl* layer_impl,
const gfx::Rect& occluded);
void AppendQuadsForPassWithOcclusion(LayerImpl* layer_impl,
RenderPass* given_render_pass,
const gfx::Rect& occluded);
void AppendSurfaceQuadsWithOcclusion(RenderSurfaceImpl* surface_impl,
const gfx::Rect& occluded);
OutputSurface* output_surface() const {
return host_->host_impl()->output_surface();
}
ResourceProvider* resource_provider() const {
return host_->host_impl()->resource_provider();
}
LayerImpl* root_layer() const { return root_layer_impl_.get(); }
FakeLayerTreeHost* host() { return host_.get(); }
FakeLayerTreeHostImpl* host_impl() const { return host_->host_impl(); }
TaskRunnerProvider* task_runner_provider() const {
return host_->host_impl()->task_runner_provider();
}
const QuadList& quad_list() const { return render_pass_->quad_list; }
private:
FakeLayerTreeHostClient client_;
TestTaskGraphRunner task_graph_runner_;
scoped_ptr<OutputSurface> output_surface_;
scoped_ptr<FakeLayerTreeHost> host_;
scoped_ptr<LayerImpl> root_layer_impl_;
scoped_ptr<RenderPass> render_pass_;
int layer_impl_id_;
};
};
} // namespace cc
#endif // CC_TEST_LAYER_TEST_COMMON_H_
|
