OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/test/null_task_runner.h" | |
6 #include "cc/output/compositor_frame.h" | 5 #include "cc/output/compositor_frame.h" |
7 #include "cc/output/copy_output_result.h" | 6 #include "cc/output/copy_output_result.h" |
8 #include "cc/output/delegated_frame_data.h" | 7 #include "cc/output/delegated_frame_data.h" |
9 #include "cc/quads/render_pass.h" | 8 #include "cc/quads/render_pass.h" |
10 #include "cc/resources/shared_bitmap_manager.h" | 9 #include "cc/resources/shared_bitmap_manager.h" |
11 #include "cc/surfaces/display.h" | 10 #include "cc/surfaces/display.h" |
12 #include "cc/surfaces/display_client.h" | 11 #include "cc/surfaces/display_client.h" |
13 #include "cc/surfaces/surface.h" | 12 #include "cc/surfaces/surface.h" |
14 #include "cc/surfaces/surface_factory.h" | 13 #include "cc/surfaces/surface_factory.h" |
15 #include "cc/surfaces/surface_factory_client.h" | 14 #include "cc/surfaces/surface_factory_client.h" |
16 #include "cc/surfaces/surface_id_allocator.h" | 15 #include "cc/surfaces/surface_id_allocator.h" |
17 #include "cc/surfaces/surface_manager.h" | 16 #include "cc/surfaces/surface_manager.h" |
18 #include "cc/test/fake_output_surface.h" | 17 #include "cc/test/fake_output_surface.h" |
19 #include "cc/test/scheduler_test_common.h" | |
20 #include "cc/test/test_shared_bitmap_manager.h" | 18 #include "cc/test/test_shared_bitmap_manager.h" |
21 #include "testing/gmock/include/gmock/gmock.h" | 19 #include "testing/gmock/include/gmock/gmock.h" |
22 #include "testing/gtest/include/gtest/gtest.h" | 20 #include "testing/gtest/include/gtest/gtest.h" |
23 | 21 |
24 namespace cc { | 22 namespace cc { |
25 namespace { | 23 namespace { |
26 | 24 |
27 class EmptySurfaceFactoryClient : public SurfaceFactoryClient { | 25 class EmptySurfaceFactoryClient : public SurfaceFactoryClient { |
28 public: | 26 public: |
29 void ReturnResources(const ReturnedResourceArray& resources) override {} | 27 void ReturnResources(const ReturnedResourceArray& resources) override {} |
(...skipping 20 matching lines...) Expand all Loading... |
50 | 48 |
51 factory_.SubmitFrame(surface_id, frame.Pass(), | 49 factory_.SubmitFrame(surface_id, frame.Pass(), |
52 SurfaceFactory::DrawCallback()); | 50 SurfaceFactory::DrawCallback()); |
53 } | 51 } |
54 | 52 |
55 SurfaceManager manager_; | 53 SurfaceManager manager_; |
56 EmptySurfaceFactoryClient empty_client_; | 54 EmptySurfaceFactoryClient empty_client_; |
57 SurfaceFactory factory_; | 55 SurfaceFactory factory_; |
58 scoped_ptr<FakeOutputSurface> output_surface_; | 56 scoped_ptr<FakeOutputSurface> output_surface_; |
59 FakeOutputSurface* output_surface_ptr_; | 57 FakeOutputSurface* output_surface_ptr_; |
60 FakeBeginFrameSource fake_begin_frame_source_; | |
61 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_; | 58 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_; |
62 }; | 59 }; |
63 | 60 |
64 class TestDisplayClient : public DisplayClient { | 61 class TestDisplayClient : public DisplayClient { |
65 public: | 62 public: |
66 TestDisplayClient() {} | 63 TestDisplayClient() : damaged(false), swapped(false) {} |
67 ~TestDisplayClient() override {} | 64 ~TestDisplayClient() override {} |
68 | 65 |
| 66 void DisplayDamaged() override { damaged = true; } |
| 67 void DidSwapBuffers() override { swapped = true; } |
| 68 void DidSwapBuffersComplete() override {} |
69 void CommitVSyncParameters(base::TimeTicks timebase, | 69 void CommitVSyncParameters(base::TimeTicks timebase, |
70 base::TimeDelta interval) override {} | 70 base::TimeDelta interval) override {} |
71 void OutputSurfaceLost() override {} | 71 void OutputSurfaceLost() override {} |
72 void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override {} | 72 void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override {} |
73 }; | |
74 | |
75 class TestDisplayScheduler : public DisplayScheduler { | |
76 public: | |
77 TestDisplayScheduler(DisplaySchedulerClient* client, | |
78 BeginFrameSource* begin_frame_source) | |
79 : DisplayScheduler(client, | |
80 begin_frame_source, | |
81 make_scoped_refptr(new base::NullTaskRunner), | |
82 1), | |
83 damaged(false), | |
84 entire_display_damaged(false), | |
85 swapped(false) {} | |
86 | |
87 ~TestDisplayScheduler() override {} | |
88 | |
89 void EntireDisplayDamaged() override { entire_display_damaged = true; } | |
90 | |
91 void SurfaceDamaged(SurfaceId surface_id) override { damaged = true; } | |
92 | |
93 void DidSwapBuffers() override { swapped = true; } | |
94 | |
95 void ResetDamageForTest() { | |
96 damaged = false; | |
97 entire_display_damaged = false; | |
98 } | |
99 | 73 |
100 bool damaged; | 74 bool damaged; |
101 bool entire_display_damaged; | |
102 bool swapped; | 75 bool swapped; |
103 }; | 76 }; |
104 | 77 |
105 void CopyCallback(bool* called, scoped_ptr<CopyOutputResult> result) { | 78 void CopyCallback(bool* called, scoped_ptr<CopyOutputResult> result) { |
106 *called = true; | 79 *called = true; |
107 } | 80 } |
108 | 81 |
109 // Check that frame is damaged and swapped only under correct conditions. | 82 // Check that frame is damaged and swapped only under correct conditions. |
110 TEST_F(DisplayTest, DisplayDamaged) { | 83 TEST_F(DisplayTest, DisplayDamaged) { |
111 TestDisplayClient client; | 84 TestDisplayClient client; |
112 RendererSettings settings; | 85 RendererSettings settings; |
113 settings.partial_swap_enabled = true; | 86 settings.partial_swap_enabled = true; |
114 Display display(&client, &manager_, shared_bitmap_manager_.get(), nullptr, | 87 Display display(&client, &manager_, shared_bitmap_manager_.get(), nullptr, |
115 settings); | 88 settings); |
116 | 89 |
117 TestDisplayScheduler scheduler(&display, &fake_begin_frame_source_); | 90 display.Initialize(output_surface_.Pass()); |
118 display.Initialize(output_surface_.Pass(), &scheduler); | |
119 | 91 |
120 SurfaceId surface_id(7u); | 92 SurfaceId surface_id(7u); |
121 EXPECT_FALSE(scheduler.damaged); | 93 EXPECT_FALSE(client.damaged); |
122 EXPECT_FALSE(scheduler.entire_display_damaged); | |
123 display.SetSurfaceId(surface_id, 1.f); | 94 display.SetSurfaceId(surface_id, 1.f); |
124 EXPECT_FALSE(scheduler.damaged); | 95 EXPECT_TRUE(client.damaged); |
125 EXPECT_TRUE(scheduler.entire_display_damaged); | |
126 | 96 |
127 scheduler.ResetDamageForTest(); | 97 client.damaged = false; |
128 display.Resize(gfx::Size(100, 100)); | 98 display.Resize(gfx::Size(100, 100)); |
129 EXPECT_FALSE(scheduler.damaged); | 99 EXPECT_TRUE(client.damaged); |
130 EXPECT_TRUE(scheduler.entire_display_damaged); | |
131 | 100 |
132 factory_.Create(surface_id); | 101 factory_.Create(surface_id); |
133 | 102 |
134 // First draw from surface should have full damage. | 103 // First draw from surface should have full damage. |
135 RenderPassList pass_list; | 104 RenderPassList pass_list; |
136 scoped_ptr<RenderPass> pass = RenderPass::Create(); | 105 scoped_ptr<RenderPass> pass = RenderPass::Create(); |
137 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 106 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
138 pass->damage_rect = gfx::Rect(10, 10, 1, 1); | 107 pass->damage_rect = gfx::Rect(10, 10, 1, 1); |
139 pass->id = RenderPassId(1, 1); | 108 pass->id = RenderPassId(1, 1); |
140 pass_list.push_back(pass.Pass()); | 109 pass_list.push_back(pass.Pass()); |
141 | 110 |
142 scheduler.ResetDamageForTest(); | 111 client.damaged = false; |
143 SubmitFrame(&pass_list, surface_id); | 112 SubmitFrame(&pass_list, surface_id); |
144 EXPECT_TRUE(scheduler.damaged); | 113 EXPECT_TRUE(client.damaged); |
145 EXPECT_FALSE(scheduler.entire_display_damaged); | |
146 | 114 |
147 EXPECT_FALSE(scheduler.swapped); | 115 EXPECT_FALSE(client.swapped); |
148 EXPECT_EQ(0u, output_surface_ptr_->num_sent_frames()); | 116 EXPECT_EQ(0u, output_surface_ptr_->num_sent_frames()); |
149 display.DrawAndSwap(); | 117 display.Draw(); |
150 EXPECT_TRUE(scheduler.swapped); | 118 EXPECT_TRUE(client.swapped); |
151 EXPECT_EQ(1u, output_surface_ptr_->num_sent_frames()); | 119 EXPECT_EQ(1u, output_surface_ptr_->num_sent_frames()); |
152 SoftwareFrameData* software_data = | 120 SoftwareFrameData* software_data = |
153 output_surface_ptr_->last_sent_frame().software_frame_data.get(); | 121 output_surface_ptr_->last_sent_frame().software_frame_data.get(); |
154 ASSERT_NE(nullptr, software_data); | 122 ASSERT_NE(nullptr, software_data); |
155 EXPECT_EQ(gfx::Size(100, 100).ToString(), software_data->size.ToString()); | 123 EXPECT_EQ(gfx::Size(100, 100).ToString(), software_data->size.ToString()); |
156 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), | 124 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), |
157 software_data->damage_rect.ToString()); | 125 software_data->damage_rect.ToString()); |
158 | 126 |
159 { | 127 { |
160 // Only damaged portion should be swapped. | 128 // Only damaged portion should be swapped. |
161 pass = RenderPass::Create(); | 129 pass = RenderPass::Create(); |
162 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 130 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
163 pass->damage_rect = gfx::Rect(10, 10, 1, 1); | 131 pass->damage_rect = gfx::Rect(10, 10, 1, 1); |
164 pass->id = RenderPassId(1, 1); | 132 pass->id = RenderPassId(1, 1); |
165 | 133 |
166 pass_list.push_back(pass.Pass()); | 134 pass_list.push_back(pass.Pass()); |
167 scheduler.ResetDamageForTest(); | 135 client.damaged = false; |
168 SubmitFrame(&pass_list, surface_id); | 136 SubmitFrame(&pass_list, surface_id); |
169 EXPECT_TRUE(scheduler.damaged); | 137 EXPECT_TRUE(client.damaged); |
170 EXPECT_FALSE(scheduler.entire_display_damaged); | |
171 | 138 |
172 scheduler.swapped = false; | 139 client.swapped = false; |
173 display.DrawAndSwap(); | 140 display.Draw(); |
174 EXPECT_TRUE(scheduler.swapped); | 141 EXPECT_TRUE(client.swapped); |
175 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); | 142 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); |
176 software_data = | 143 software_data = |
177 output_surface_ptr_->last_sent_frame().software_frame_data.get(); | 144 output_surface_ptr_->last_sent_frame().software_frame_data.get(); |
178 ASSERT_NE(nullptr, software_data); | 145 ASSERT_NE(nullptr, software_data); |
179 EXPECT_EQ(gfx::Size(100, 100).ToString(), software_data->size.ToString()); | 146 EXPECT_EQ(gfx::Size(100, 100).ToString(), software_data->size.ToString()); |
180 EXPECT_EQ(gfx::Rect(10, 10, 1, 1).ToString(), | 147 EXPECT_EQ(gfx::Rect(10, 10, 1, 1).ToString(), |
181 software_data->damage_rect.ToString()); | 148 software_data->damage_rect.ToString()); |
182 } | 149 } |
183 | 150 |
184 { | 151 { |
185 // Pass has no damage so shouldn't be swapped. | 152 // Pass has no damage so shouldn't be swapped. |
186 pass = RenderPass::Create(); | 153 pass = RenderPass::Create(); |
187 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 154 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
188 pass->damage_rect = gfx::Rect(10, 10, 0, 0); | 155 pass->damage_rect = gfx::Rect(10, 10, 0, 0); |
189 pass->id = RenderPassId(1, 1); | 156 pass->id = RenderPassId(1, 1); |
190 | 157 |
191 pass_list.push_back(pass.Pass()); | 158 pass_list.push_back(pass.Pass()); |
192 scheduler.ResetDamageForTest(); | 159 client.damaged = false; |
193 SubmitFrame(&pass_list, surface_id); | 160 SubmitFrame(&pass_list, surface_id); |
194 EXPECT_TRUE(scheduler.damaged); | 161 EXPECT_TRUE(client.damaged); |
195 EXPECT_FALSE(scheduler.entire_display_damaged); | |
196 | 162 |
197 scheduler.swapped = false; | 163 client.swapped = false; |
198 display.DrawAndSwap(); | 164 display.Draw(); |
199 EXPECT_TRUE(scheduler.swapped); | 165 EXPECT_TRUE(client.swapped); |
200 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); | 166 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); |
201 } | 167 } |
202 | 168 |
203 { | 169 { |
204 // Pass is wrong size so shouldn't be swapped. | 170 // Pass is wrong size so shouldn't be swapped. |
205 pass = RenderPass::Create(); | 171 pass = RenderPass::Create(); |
206 pass->output_rect = gfx::Rect(0, 0, 99, 99); | 172 pass->output_rect = gfx::Rect(0, 0, 99, 99); |
207 pass->damage_rect = gfx::Rect(10, 10, 10, 10); | 173 pass->damage_rect = gfx::Rect(10, 10, 10, 10); |
208 pass->id = RenderPassId(1, 1); | 174 pass->id = RenderPassId(1, 1); |
209 | 175 |
210 pass_list.push_back(pass.Pass()); | 176 pass_list.push_back(pass.Pass()); |
211 scheduler.ResetDamageForTest(); | 177 client.damaged = false; |
212 SubmitFrame(&pass_list, surface_id); | 178 SubmitFrame(&pass_list, surface_id); |
213 EXPECT_TRUE(scheduler.damaged); | 179 EXPECT_TRUE(client.damaged); |
214 EXPECT_FALSE(scheduler.entire_display_damaged); | |
215 | 180 |
216 scheduler.swapped = false; | 181 client.swapped = false; |
217 display.DrawAndSwap(); | 182 display.Draw(); |
218 EXPECT_TRUE(scheduler.swapped); | 183 EXPECT_TRUE(client.swapped); |
219 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); | 184 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); |
220 } | 185 } |
221 | 186 |
222 { | 187 { |
223 // Pass has copy output request so should be swapped. | 188 // Pass has copy output request so should be swapped. |
224 pass = RenderPass::Create(); | 189 pass = RenderPass::Create(); |
225 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 190 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
226 pass->damage_rect = gfx::Rect(10, 10, 0, 0); | 191 pass->damage_rect = gfx::Rect(10, 10, 0, 0); |
227 bool copy_called = false; | 192 bool copy_called = false; |
228 pass->copy_requests.push_back(CopyOutputRequest::CreateRequest( | 193 pass->copy_requests.push_back(CopyOutputRequest::CreateRequest( |
229 base::Bind(&CopyCallback, ©_called))); | 194 base::Bind(&CopyCallback, ©_called))); |
230 pass->id = RenderPassId(1, 1); | 195 pass->id = RenderPassId(1, 1); |
231 | 196 |
232 pass_list.push_back(pass.Pass()); | 197 pass_list.push_back(pass.Pass()); |
233 scheduler.ResetDamageForTest(); | 198 client.damaged = false; |
234 SubmitFrame(&pass_list, surface_id); | 199 SubmitFrame(&pass_list, surface_id); |
235 EXPECT_TRUE(scheduler.damaged); | 200 EXPECT_TRUE(client.damaged); |
236 EXPECT_FALSE(scheduler.entire_display_damaged); | |
237 | 201 |
238 scheduler.swapped = false; | 202 client.swapped = false; |
239 display.DrawAndSwap(); | 203 display.Draw(); |
240 EXPECT_TRUE(scheduler.swapped); | 204 EXPECT_TRUE(client.swapped); |
241 EXPECT_EQ(3u, output_surface_ptr_->num_sent_frames()); | 205 EXPECT_EQ(3u, output_surface_ptr_->num_sent_frames()); |
242 EXPECT_TRUE(copy_called); | 206 EXPECT_TRUE(copy_called); |
243 } | 207 } |
244 | 208 |
245 // Pass has latency info so should be swapped. | 209 // Pass has latency info so should be swapped. |
246 { | 210 { |
247 pass = RenderPass::Create(); | 211 pass = RenderPass::Create(); |
248 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 212 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
249 pass->damage_rect = gfx::Rect(10, 10, 0, 0); | 213 pass->damage_rect = gfx::Rect(10, 10, 0, 0); |
250 pass->id = RenderPassId(1, 1); | 214 pass->id = RenderPassId(1, 1); |
251 | 215 |
252 pass_list.push_back(pass.Pass()); | 216 pass_list.push_back(pass.Pass()); |
253 scheduler.ResetDamageForTest(); | 217 client.damaged = false; |
254 scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData); | 218 scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData); |
255 pass_list.swap(frame_data->render_pass_list); | 219 pass_list.swap(frame_data->render_pass_list); |
256 | 220 |
257 scoped_ptr<CompositorFrame> frame(new CompositorFrame); | 221 scoped_ptr<CompositorFrame> frame(new CompositorFrame); |
258 frame->delegated_frame_data = frame_data.Pass(); | 222 frame->delegated_frame_data = frame_data.Pass(); |
259 frame->metadata.latency_info.push_back(ui::LatencyInfo()); | 223 frame->metadata.latency_info.push_back(ui::LatencyInfo()); |
260 | 224 |
261 factory_.SubmitFrame(surface_id, frame.Pass(), | 225 factory_.SubmitFrame(surface_id, frame.Pass(), |
262 SurfaceFactory::DrawCallback()); | 226 SurfaceFactory::DrawCallback()); |
263 EXPECT_TRUE(scheduler.damaged); | 227 EXPECT_TRUE(client.damaged); |
264 EXPECT_FALSE(scheduler.entire_display_damaged); | |
265 | 228 |
266 scheduler.swapped = false; | 229 client.swapped = false; |
267 display.DrawAndSwap(); | 230 display.Draw(); |
268 EXPECT_TRUE(scheduler.swapped); | 231 EXPECT_TRUE(client.swapped); |
269 EXPECT_EQ(4u, output_surface_ptr_->num_sent_frames()); | 232 EXPECT_EQ(4u, output_surface_ptr_->num_sent_frames()); |
270 } | 233 } |
271 | 234 |
272 factory_.Destroy(surface_id); | 235 factory_.Destroy(surface_id); |
273 } | 236 } |
274 | 237 |
275 } // namespace | 238 } // namespace |
276 } // namespace cc | 239 } // namespace cc |
OLD | NEW |