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 "cc/surfaces/display.h" | 5 #include "cc/surfaces/display.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/test/null_task_runner.h" | 9 #include "base/test/null_task_runner.h" |
10 #include "cc/output/compositor_frame.h" | 10 #include "cc/output/compositor_frame.h" |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
93 bool damaged; | 93 bool damaged; |
94 bool display_resized_; | 94 bool display_resized_; |
95 bool has_new_root_surface; | 95 bool has_new_root_surface; |
96 bool swapped; | 96 bool swapped; |
97 }; | 97 }; |
98 | 98 |
99 class DisplayTest : public testing::Test { | 99 class DisplayTest : public testing::Test { |
100 public: | 100 public: |
101 DisplayTest() | 101 DisplayTest() |
102 : factory_(kArbitraryFrameSinkId, &manager_, &surface_factory_client_), | 102 : factory_(kArbitraryFrameSinkId, &manager_, &surface_factory_client_), |
103 id_allocator_(kArbitraryFrameSinkId), | |
104 task_runner_(new base::NullTaskRunner) { | 103 task_runner_(new base::NullTaskRunner) { |
105 manager_.RegisterFrameSinkId(kArbitraryFrameSinkId); | 104 manager_.RegisterFrameSinkId(kArbitraryFrameSinkId); |
106 } | 105 } |
107 | 106 |
108 ~DisplayTest() override { | 107 ~DisplayTest() override { |
109 manager_.InvalidateFrameSinkId(kArbitraryFrameSinkId); | 108 manager_.InvalidateFrameSinkId(kArbitraryFrameSinkId); |
110 } | 109 } |
111 | 110 |
112 void SetUpDisplay(const RendererSettings& settings, | 111 void SetUpDisplay(const RendererSettings& settings, |
113 std::unique_ptr<TestWebGraphicsContext3D> context) { | 112 std::unique_ptr<TestWebGraphicsContext3D> context) { |
(...skipping 18 matching lines...) Expand all Loading... |
132 display_ = base::MakeUnique<Display>( | 131 display_ = base::MakeUnique<Display>( |
133 &shared_bitmap_manager_, nullptr /* gpu_memory_buffer_manager */, | 132 &shared_bitmap_manager_, nullptr /* gpu_memory_buffer_manager */, |
134 settings, std::move(begin_frame_source), std::move(output_surface), | 133 settings, std::move(begin_frame_source), std::move(output_surface), |
135 std::move(scheduler), | 134 std::move(scheduler), |
136 base::MakeUnique<TextureMailboxDeleter>(task_runner_.get())); | 135 base::MakeUnique<TextureMailboxDeleter>(task_runner_.get())); |
137 display_->SetVisible(true); | 136 display_->SetVisible(true); |
138 } | 137 } |
139 | 138 |
140 protected: | 139 protected: |
141 void SubmitCompositorFrame(RenderPassList* pass_list, | 140 void SubmitCompositorFrame(RenderPassList* pass_list, |
142 const SurfaceId& surface_id) { | 141 const LocalFrameId& local_frame_id) { |
143 std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData); | 142 std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData); |
144 pass_list->swap(frame_data->render_pass_list); | 143 pass_list->swap(frame_data->render_pass_list); |
145 | 144 |
146 CompositorFrame frame; | 145 CompositorFrame frame; |
147 frame.delegated_frame_data = std::move(frame_data); | 146 frame.delegated_frame_data = std::move(frame_data); |
148 | 147 |
149 factory_.SubmitCompositorFrame(surface_id, std::move(frame), | 148 factory_.SubmitCompositorFrame(local_frame_id, std::move(frame), |
150 SurfaceFactory::DrawCallback()); | 149 SurfaceFactory::DrawCallback()); |
151 } | 150 } |
152 | 151 |
153 SurfaceManager manager_; | 152 SurfaceManager manager_; |
154 FakeSurfaceFactoryClient surface_factory_client_; | 153 FakeSurfaceFactoryClient surface_factory_client_; |
155 SurfaceFactory factory_; | 154 SurfaceFactory factory_; |
156 SurfaceIdAllocator id_allocator_; | 155 SurfaceIdAllocator id_allocator_; |
157 scoped_refptr<base::NullTaskRunner> task_runner_; | 156 scoped_refptr<base::NullTaskRunner> task_runner_; |
158 TestSharedBitmapManager shared_bitmap_manager_; | 157 TestSharedBitmapManager shared_bitmap_manager_; |
159 std::unique_ptr<Display> display_; | 158 std::unique_ptr<Display> display_; |
(...skipping 17 matching lines...) Expand all Loading... |
177 // Check that frame is damaged and swapped only under correct conditions. | 176 // Check that frame is damaged and swapped only under correct conditions. |
178 TEST_F(DisplayTest, DisplayDamaged) { | 177 TEST_F(DisplayTest, DisplayDamaged) { |
179 RendererSettings settings; | 178 RendererSettings settings; |
180 settings.partial_swap_enabled = true; | 179 settings.partial_swap_enabled = true; |
181 settings.finish_rendering_on_resize = true; | 180 settings.finish_rendering_on_resize = true; |
182 SetUpDisplay(settings, nullptr); | 181 SetUpDisplay(settings, nullptr); |
183 | 182 |
184 StubDisplayClient client; | 183 StubDisplayClient client; |
185 display_->Initialize(&client, &manager_, kArbitraryFrameSinkId); | 184 display_->Initialize(&client, &manager_, kArbitraryFrameSinkId); |
186 | 185 |
187 SurfaceId surface_id(id_allocator_.GenerateId()); | 186 LocalFrameId local_frame_id(id_allocator_.GenerateId()); |
| 187 SurfaceId surface_id(factory_.frame_sink_id(), local_frame_id); |
188 EXPECT_FALSE(scheduler_->damaged); | 188 EXPECT_FALSE(scheduler_->damaged); |
189 EXPECT_FALSE(scheduler_->has_new_root_surface); | 189 EXPECT_FALSE(scheduler_->has_new_root_surface); |
190 display_->SetSurfaceId(surface_id, 1.f); | 190 display_->SetSurfaceId(surface_id, 1.f); |
191 EXPECT_FALSE(scheduler_->damaged); | 191 EXPECT_FALSE(scheduler_->damaged); |
192 EXPECT_FALSE(scheduler_->display_resized_); | 192 EXPECT_FALSE(scheduler_->display_resized_); |
193 EXPECT_TRUE(scheduler_->has_new_root_surface); | 193 EXPECT_TRUE(scheduler_->has_new_root_surface); |
194 | 194 |
195 scheduler_->ResetDamageForTest(); | 195 scheduler_->ResetDamageForTest(); |
196 display_->Resize(gfx::Size(100, 100)); | 196 display_->Resize(gfx::Size(100, 100)); |
197 EXPECT_FALSE(scheduler_->damaged); | 197 EXPECT_FALSE(scheduler_->damaged); |
198 EXPECT_TRUE(scheduler_->display_resized_); | 198 EXPECT_TRUE(scheduler_->display_resized_); |
199 EXPECT_FALSE(scheduler_->has_new_root_surface); | 199 EXPECT_FALSE(scheduler_->has_new_root_surface); |
200 | 200 |
201 factory_.Create(surface_id); | 201 factory_.Create(local_frame_id); |
202 | 202 |
203 // First draw from surface should have full damage. | 203 // First draw from surface should have full damage. |
204 RenderPassList pass_list; | 204 RenderPassList pass_list; |
205 std::unique_ptr<RenderPass> pass = RenderPass::Create(); | 205 std::unique_ptr<RenderPass> pass = RenderPass::Create(); |
206 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 206 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
207 pass->damage_rect = gfx::Rect(10, 10, 1, 1); | 207 pass->damage_rect = gfx::Rect(10, 10, 1, 1); |
208 pass->id = RenderPassId(1, 1); | 208 pass->id = RenderPassId(1, 1); |
209 pass_list.push_back(std::move(pass)); | 209 pass_list.push_back(std::move(pass)); |
210 | 210 |
211 scheduler_->ResetDamageForTest(); | 211 scheduler_->ResetDamageForTest(); |
212 SubmitCompositorFrame(&pass_list, surface_id); | 212 SubmitCompositorFrame(&pass_list, local_frame_id); |
213 EXPECT_TRUE(scheduler_->damaged); | 213 EXPECT_TRUE(scheduler_->damaged); |
214 EXPECT_FALSE(scheduler_->display_resized_); | 214 EXPECT_FALSE(scheduler_->display_resized_); |
215 EXPECT_FALSE(scheduler_->has_new_root_surface); | 215 EXPECT_FALSE(scheduler_->has_new_root_surface); |
216 | 216 |
217 EXPECT_FALSE(scheduler_->swapped); | 217 EXPECT_FALSE(scheduler_->swapped); |
218 EXPECT_EQ(0u, output_surface_->num_sent_frames()); | 218 EXPECT_EQ(0u, output_surface_->num_sent_frames()); |
219 display_->DrawAndSwap(); | 219 display_->DrawAndSwap(); |
220 EXPECT_TRUE(scheduler_->swapped); | 220 EXPECT_TRUE(scheduler_->swapped); |
221 EXPECT_EQ(1u, output_surface_->num_sent_frames()); | 221 EXPECT_EQ(1u, output_surface_->num_sent_frames()); |
222 EXPECT_EQ(gfx::Size(100, 100), | 222 EXPECT_EQ(gfx::Size(100, 100), |
223 software_output_device_->viewport_pixel_size()); | 223 software_output_device_->viewport_pixel_size()); |
224 EXPECT_EQ(gfx::Rect(0, 0, 100, 100), software_output_device_->damage_rect()); | 224 EXPECT_EQ(gfx::Rect(0, 0, 100, 100), software_output_device_->damage_rect()); |
225 | 225 |
226 { | 226 { |
227 // Only damaged portion should be swapped. | 227 // Only damaged portion should be swapped. |
228 pass = RenderPass::Create(); | 228 pass = RenderPass::Create(); |
229 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 229 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
230 pass->damage_rect = gfx::Rect(10, 10, 1, 1); | 230 pass->damage_rect = gfx::Rect(10, 10, 1, 1); |
231 pass->id = RenderPassId(1, 1); | 231 pass->id = RenderPassId(1, 1); |
232 | 232 |
233 pass_list.push_back(std::move(pass)); | 233 pass_list.push_back(std::move(pass)); |
234 scheduler_->ResetDamageForTest(); | 234 scheduler_->ResetDamageForTest(); |
235 SubmitCompositorFrame(&pass_list, surface_id); | 235 SubmitCompositorFrame(&pass_list, local_frame_id); |
236 EXPECT_TRUE(scheduler_->damaged); | 236 EXPECT_TRUE(scheduler_->damaged); |
237 EXPECT_FALSE(scheduler_->display_resized_); | 237 EXPECT_FALSE(scheduler_->display_resized_); |
238 EXPECT_FALSE(scheduler_->has_new_root_surface); | 238 EXPECT_FALSE(scheduler_->has_new_root_surface); |
239 | 239 |
240 scheduler_->swapped = false; | 240 scheduler_->swapped = false; |
241 display_->DrawAndSwap(); | 241 display_->DrawAndSwap(); |
242 EXPECT_TRUE(scheduler_->swapped); | 242 EXPECT_TRUE(scheduler_->swapped); |
243 EXPECT_EQ(2u, output_surface_->num_sent_frames()); | 243 EXPECT_EQ(2u, output_surface_->num_sent_frames()); |
244 EXPECT_EQ(gfx::Size(100, 100), | 244 EXPECT_EQ(gfx::Size(100, 100), |
245 software_output_device_->viewport_pixel_size()); | 245 software_output_device_->viewport_pixel_size()); |
246 EXPECT_EQ(gfx::Rect(10, 10, 1, 1), software_output_device_->damage_rect()); | 246 EXPECT_EQ(gfx::Rect(10, 10, 1, 1), software_output_device_->damage_rect()); |
247 } | 247 } |
248 | 248 |
249 { | 249 { |
250 // Pass has no damage so shouldn't be swapped. | 250 // Pass has no damage so shouldn't be swapped. |
251 pass = RenderPass::Create(); | 251 pass = RenderPass::Create(); |
252 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 252 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
253 pass->damage_rect = gfx::Rect(10, 10, 0, 0); | 253 pass->damage_rect = gfx::Rect(10, 10, 0, 0); |
254 pass->id = RenderPassId(1, 1); | 254 pass->id = RenderPassId(1, 1); |
255 | 255 |
256 pass_list.push_back(std::move(pass)); | 256 pass_list.push_back(std::move(pass)); |
257 scheduler_->ResetDamageForTest(); | 257 scheduler_->ResetDamageForTest(); |
258 SubmitCompositorFrame(&pass_list, surface_id); | 258 SubmitCompositorFrame(&pass_list, local_frame_id); |
259 EXPECT_TRUE(scheduler_->damaged); | 259 EXPECT_TRUE(scheduler_->damaged); |
260 EXPECT_FALSE(scheduler_->display_resized_); | 260 EXPECT_FALSE(scheduler_->display_resized_); |
261 EXPECT_FALSE(scheduler_->has_new_root_surface); | 261 EXPECT_FALSE(scheduler_->has_new_root_surface); |
262 | 262 |
263 scheduler_->swapped = false; | 263 scheduler_->swapped = false; |
264 display_->DrawAndSwap(); | 264 display_->DrawAndSwap(); |
265 EXPECT_TRUE(scheduler_->swapped); | 265 EXPECT_TRUE(scheduler_->swapped); |
266 EXPECT_EQ(2u, output_surface_->num_sent_frames()); | 266 EXPECT_EQ(2u, output_surface_->num_sent_frames()); |
267 } | 267 } |
268 | 268 |
269 { | 269 { |
270 // Pass is wrong size so shouldn't be swapped. | 270 // Pass is wrong size so shouldn't be swapped. |
271 pass = RenderPass::Create(); | 271 pass = RenderPass::Create(); |
272 pass->output_rect = gfx::Rect(0, 0, 99, 99); | 272 pass->output_rect = gfx::Rect(0, 0, 99, 99); |
273 pass->damage_rect = gfx::Rect(10, 10, 10, 10); | 273 pass->damage_rect = gfx::Rect(10, 10, 10, 10); |
274 pass->id = RenderPassId(1, 1); | 274 pass->id = RenderPassId(1, 1); |
275 | 275 |
276 pass_list.push_back(std::move(pass)); | 276 pass_list.push_back(std::move(pass)); |
277 scheduler_->ResetDamageForTest(); | 277 scheduler_->ResetDamageForTest(); |
278 SubmitCompositorFrame(&pass_list, surface_id); | 278 SubmitCompositorFrame(&pass_list, local_frame_id); |
279 EXPECT_TRUE(scheduler_->damaged); | 279 EXPECT_TRUE(scheduler_->damaged); |
280 EXPECT_FALSE(scheduler_->display_resized_); | 280 EXPECT_FALSE(scheduler_->display_resized_); |
281 EXPECT_FALSE(scheduler_->has_new_root_surface); | 281 EXPECT_FALSE(scheduler_->has_new_root_surface); |
282 | 282 |
283 scheduler_->swapped = false; | 283 scheduler_->swapped = false; |
284 display_->DrawAndSwap(); | 284 display_->DrawAndSwap(); |
285 EXPECT_TRUE(scheduler_->swapped); | 285 EXPECT_TRUE(scheduler_->swapped); |
286 EXPECT_EQ(2u, output_surface_->num_sent_frames()); | 286 EXPECT_EQ(2u, output_surface_->num_sent_frames()); |
287 } | 287 } |
288 | 288 |
289 { | 289 { |
290 // Previous frame wasn't swapped, so next swap should have full damage. | 290 // Previous frame wasn't swapped, so next swap should have full damage. |
291 pass = RenderPass::Create(); | 291 pass = RenderPass::Create(); |
292 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 292 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
293 pass->damage_rect = gfx::Rect(10, 10, 0, 0); | 293 pass->damage_rect = gfx::Rect(10, 10, 0, 0); |
294 pass->id = RenderPassId(1, 1); | 294 pass->id = RenderPassId(1, 1); |
295 | 295 |
296 pass_list.push_back(std::move(pass)); | 296 pass_list.push_back(std::move(pass)); |
297 scheduler_->ResetDamageForTest(); | 297 scheduler_->ResetDamageForTest(); |
298 SubmitCompositorFrame(&pass_list, surface_id); | 298 SubmitCompositorFrame(&pass_list, local_frame_id); |
299 EXPECT_TRUE(scheduler_->damaged); | 299 EXPECT_TRUE(scheduler_->damaged); |
300 EXPECT_FALSE(scheduler_->display_resized_); | 300 EXPECT_FALSE(scheduler_->display_resized_); |
301 EXPECT_FALSE(scheduler_->has_new_root_surface); | 301 EXPECT_FALSE(scheduler_->has_new_root_surface); |
302 | 302 |
303 scheduler_->swapped = false; | 303 scheduler_->swapped = false; |
304 display_->DrawAndSwap(); | 304 display_->DrawAndSwap(); |
305 EXPECT_TRUE(scheduler_->swapped); | 305 EXPECT_TRUE(scheduler_->swapped); |
306 EXPECT_EQ(3u, output_surface_->num_sent_frames()); | 306 EXPECT_EQ(3u, output_surface_->num_sent_frames()); |
307 EXPECT_EQ(gfx::Rect(0, 0, 100, 100), | 307 EXPECT_EQ(gfx::Rect(0, 0, 100, 100), |
308 software_output_device_->damage_rect()); | 308 software_output_device_->damage_rect()); |
309 } | 309 } |
310 | 310 |
311 { | 311 { |
312 // Pass has copy output request so should be swapped. | 312 // Pass has copy output request so should be swapped. |
313 pass = RenderPass::Create(); | 313 pass = RenderPass::Create(); |
314 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 314 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
315 pass->damage_rect = gfx::Rect(10, 10, 0, 0); | 315 pass->damage_rect = gfx::Rect(10, 10, 0, 0); |
316 bool copy_called = false; | 316 bool copy_called = false; |
317 pass->copy_requests.push_back(CopyOutputRequest::CreateRequest( | 317 pass->copy_requests.push_back(CopyOutputRequest::CreateRequest( |
318 base::Bind(&CopyCallback, ©_called))); | 318 base::Bind(&CopyCallback, ©_called))); |
319 pass->id = RenderPassId(1, 1); | 319 pass->id = RenderPassId(1, 1); |
320 | 320 |
321 pass_list.push_back(std::move(pass)); | 321 pass_list.push_back(std::move(pass)); |
322 scheduler_->ResetDamageForTest(); | 322 scheduler_->ResetDamageForTest(); |
323 SubmitCompositorFrame(&pass_list, surface_id); | 323 SubmitCompositorFrame(&pass_list, local_frame_id); |
324 EXPECT_TRUE(scheduler_->damaged); | 324 EXPECT_TRUE(scheduler_->damaged); |
325 EXPECT_FALSE(scheduler_->display_resized_); | 325 EXPECT_FALSE(scheduler_->display_resized_); |
326 EXPECT_FALSE(scheduler_->has_new_root_surface); | 326 EXPECT_FALSE(scheduler_->has_new_root_surface); |
327 | 327 |
328 scheduler_->swapped = false; | 328 scheduler_->swapped = false; |
329 display_->DrawAndSwap(); | 329 display_->DrawAndSwap(); |
330 EXPECT_TRUE(scheduler_->swapped); | 330 EXPECT_TRUE(scheduler_->swapped); |
331 EXPECT_EQ(4u, output_surface_->num_sent_frames()); | 331 EXPECT_EQ(4u, output_surface_->num_sent_frames()); |
332 EXPECT_TRUE(copy_called); | 332 EXPECT_TRUE(copy_called); |
333 } | 333 } |
334 | 334 |
335 // Pass has no damage, so shouldn't be swapped, but latency info should be | 335 // Pass has no damage, so shouldn't be swapped, but latency info should be |
336 // saved for next swap. | 336 // saved for next swap. |
337 { | 337 { |
338 pass = RenderPass::Create(); | 338 pass = RenderPass::Create(); |
339 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 339 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
340 pass->damage_rect = gfx::Rect(10, 10, 0, 0); | 340 pass->damage_rect = gfx::Rect(10, 10, 0, 0); |
341 pass->id = RenderPassId(1, 1); | 341 pass->id = RenderPassId(1, 1); |
342 | 342 |
343 pass_list.push_back(std::move(pass)); | 343 pass_list.push_back(std::move(pass)); |
344 scheduler_->ResetDamageForTest(); | 344 scheduler_->ResetDamageForTest(); |
345 std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData); | 345 std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData); |
346 pass_list.swap(frame_data->render_pass_list); | 346 pass_list.swap(frame_data->render_pass_list); |
347 | 347 |
348 CompositorFrame frame; | 348 CompositorFrame frame; |
349 frame.delegated_frame_data = std::move(frame_data); | 349 frame.delegated_frame_data = std::move(frame_data); |
350 frame.metadata.latency_info.push_back(ui::LatencyInfo()); | 350 frame.metadata.latency_info.push_back(ui::LatencyInfo()); |
351 | 351 |
352 factory_.SubmitCompositorFrame(surface_id, std::move(frame), | 352 factory_.SubmitCompositorFrame(local_frame_id, std::move(frame), |
353 SurfaceFactory::DrawCallback()); | 353 SurfaceFactory::DrawCallback()); |
354 EXPECT_TRUE(scheduler_->damaged); | 354 EXPECT_TRUE(scheduler_->damaged); |
355 EXPECT_FALSE(scheduler_->display_resized_); | 355 EXPECT_FALSE(scheduler_->display_resized_); |
356 EXPECT_FALSE(scheduler_->has_new_root_surface); | 356 EXPECT_FALSE(scheduler_->has_new_root_surface); |
357 | 357 |
358 scheduler_->swapped = false; | 358 scheduler_->swapped = false; |
359 display_->DrawAndSwap(); | 359 display_->DrawAndSwap(); |
360 EXPECT_TRUE(scheduler_->swapped); | 360 EXPECT_TRUE(scheduler_->swapped); |
361 EXPECT_EQ(4u, output_surface_->num_sent_frames()); | 361 EXPECT_EQ(4u, output_surface_->num_sent_frames()); |
362 } | 362 } |
(...skipping 11 matching lines...) Expand all Loading... |
374 pass->id = RenderPassId(1, 1); | 374 pass->id = RenderPassId(1, 1); |
375 | 375 |
376 pass_list.push_back(std::move(pass)); | 376 pass_list.push_back(std::move(pass)); |
377 scheduler_->ResetDamageForTest(); | 377 scheduler_->ResetDamageForTest(); |
378 std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData); | 378 std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData); |
379 pass_list.swap(frame_data->render_pass_list); | 379 pass_list.swap(frame_data->render_pass_list); |
380 | 380 |
381 CompositorFrame frame; | 381 CompositorFrame frame; |
382 frame.delegated_frame_data = std::move(frame_data); | 382 frame.delegated_frame_data = std::move(frame_data); |
383 | 383 |
384 factory_.SubmitCompositorFrame(surface_id, std::move(frame), | 384 factory_.SubmitCompositorFrame(local_frame_id, std::move(frame), |
385 SurfaceFactory::DrawCallback()); | 385 SurfaceFactory::DrawCallback()); |
386 EXPECT_TRUE(scheduler_->damaged); | 386 EXPECT_TRUE(scheduler_->damaged); |
387 EXPECT_FALSE(scheduler_->display_resized_); | 387 EXPECT_FALSE(scheduler_->display_resized_); |
388 EXPECT_FALSE(scheduler_->has_new_root_surface); | 388 EXPECT_FALSE(scheduler_->has_new_root_surface); |
389 | 389 |
390 scheduler_->swapped = false; | 390 scheduler_->swapped = false; |
391 display_->Resize(gfx::Size(100, 100)); | 391 display_->Resize(gfx::Size(100, 100)); |
392 EXPECT_TRUE(scheduler_->swapped); | 392 EXPECT_TRUE(scheduler_->swapped); |
393 EXPECT_EQ(5u, output_surface_->num_sent_frames()); | 393 EXPECT_EQ(5u, output_surface_->num_sent_frames()); |
394 | 394 |
395 // Latency info from previous frame should be sent now. | 395 // Latency info from previous frame should be sent now. |
396 EXPECT_EQ(1u, | 396 EXPECT_EQ(1u, |
397 output_surface_->last_sent_frame()->metadata.latency_info.size()); | 397 output_surface_->last_sent_frame()->metadata.latency_info.size()); |
398 } | 398 } |
399 | 399 |
400 { | 400 { |
401 // Surface that's damaged completely should be resized and swapped. | 401 // Surface that's damaged completely should be resized and swapped. |
402 pass = RenderPass::Create(); | 402 pass = RenderPass::Create(); |
403 pass->output_rect = gfx::Rect(0, 0, 99, 99); | 403 pass->output_rect = gfx::Rect(0, 0, 99, 99); |
404 pass->damage_rect = gfx::Rect(0, 0, 99, 99); | 404 pass->damage_rect = gfx::Rect(0, 0, 99, 99); |
405 pass->id = RenderPassId(1, 1); | 405 pass->id = RenderPassId(1, 1); |
406 | 406 |
407 pass_list.push_back(std::move(pass)); | 407 pass_list.push_back(std::move(pass)); |
408 scheduler_->ResetDamageForTest(); | 408 scheduler_->ResetDamageForTest(); |
409 SubmitCompositorFrame(&pass_list, surface_id); | 409 SubmitCompositorFrame(&pass_list, local_frame_id); |
410 EXPECT_TRUE(scheduler_->damaged); | 410 EXPECT_TRUE(scheduler_->damaged); |
411 EXPECT_FALSE(scheduler_->display_resized_); | 411 EXPECT_FALSE(scheduler_->display_resized_); |
412 EXPECT_FALSE(scheduler_->has_new_root_surface); | 412 EXPECT_FALSE(scheduler_->has_new_root_surface); |
413 | 413 |
414 scheduler_->swapped = false; | 414 scheduler_->swapped = false; |
415 display_->DrawAndSwap(); | 415 display_->DrawAndSwap(); |
416 EXPECT_TRUE(scheduler_->swapped); | 416 EXPECT_TRUE(scheduler_->swapped); |
417 EXPECT_EQ(6u, output_surface_->num_sent_frames()); | 417 EXPECT_EQ(6u, output_surface_->num_sent_frames()); |
418 EXPECT_EQ(gfx::Size(100, 100), | 418 EXPECT_EQ(gfx::Size(100, 100), |
419 software_output_device_->viewport_pixel_size()); | 419 software_output_device_->viewport_pixel_size()); |
420 EXPECT_EQ(gfx::Rect(0, 0, 100, 100), | 420 EXPECT_EQ(gfx::Rect(0, 0, 100, 100), |
421 software_output_device_->damage_rect()); | 421 software_output_device_->damage_rect()); |
422 EXPECT_EQ(0u, | 422 EXPECT_EQ(0u, |
423 output_surface_->last_sent_frame()->metadata.latency_info.size()); | 423 output_surface_->last_sent_frame()->metadata.latency_info.size()); |
424 } | 424 } |
425 | 425 |
426 factory_.Destroy(surface_id); | 426 factory_.Destroy(local_frame_id); |
427 } | 427 } |
428 | 428 |
429 class MockedContext : public TestWebGraphicsContext3D { | 429 class MockedContext : public TestWebGraphicsContext3D { |
430 public: | 430 public: |
431 MOCK_METHOD0(shallowFinishCHROMIUM, void()); | 431 MOCK_METHOD0(shallowFinishCHROMIUM, void()); |
432 }; | 432 }; |
433 | 433 |
434 TEST_F(DisplayTest, Finish) { | 434 TEST_F(DisplayTest, Finish) { |
435 SurfaceId surface_id(id_allocator_.GenerateId()); | 435 LocalFrameId local_frame_id(id_allocator_.GenerateId()); |
| 436 SurfaceId surface_id(factory_.frame_sink_id(), local_frame_id); |
436 | 437 |
437 RendererSettings settings; | 438 RendererSettings settings; |
438 settings.partial_swap_enabled = true; | 439 settings.partial_swap_enabled = true; |
439 settings.finish_rendering_on_resize = true; | 440 settings.finish_rendering_on_resize = true; |
440 | 441 |
441 std::unique_ptr<MockedContext> context(new MockedContext()); | 442 std::unique_ptr<MockedContext> context(new MockedContext()); |
442 MockedContext* context_ptr = context.get(); | 443 MockedContext* context_ptr = context.get(); |
443 EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0); | 444 EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0); |
444 | 445 |
445 SetUpDisplay(settings, std::move(context)); | 446 SetUpDisplay(settings, std::move(context)); |
446 | 447 |
447 StubDisplayClient client; | 448 StubDisplayClient client; |
448 display_->Initialize(&client, &manager_, kArbitraryFrameSinkId); | 449 display_->Initialize(&client, &manager_, kArbitraryFrameSinkId); |
449 | 450 |
450 display_->SetSurfaceId(surface_id, 1.f); | 451 display_->SetSurfaceId(surface_id, 1.f); |
451 | 452 |
452 display_->Resize(gfx::Size(100, 100)); | 453 display_->Resize(gfx::Size(100, 100)); |
453 factory_.Create(surface_id); | 454 factory_.Create(local_frame_id); |
454 | 455 |
455 { | 456 { |
456 RenderPassList pass_list; | 457 RenderPassList pass_list; |
457 std::unique_ptr<RenderPass> pass = RenderPass::Create(); | 458 std::unique_ptr<RenderPass> pass = RenderPass::Create(); |
458 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 459 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
459 pass->damage_rect = gfx::Rect(10, 10, 1, 1); | 460 pass->damage_rect = gfx::Rect(10, 10, 1, 1); |
460 pass->id = RenderPassId(1, 1); | 461 pass->id = RenderPassId(1, 1); |
461 pass_list.push_back(std::move(pass)); | 462 pass_list.push_back(std::move(pass)); |
462 | 463 |
463 SubmitCompositorFrame(&pass_list, surface_id); | 464 SubmitCompositorFrame(&pass_list, local_frame_id); |
464 } | 465 } |
465 | 466 |
466 display_->DrawAndSwap(); | 467 display_->DrawAndSwap(); |
467 | 468 |
468 // First resize and draw shouldn't finish. | 469 // First resize and draw shouldn't finish. |
469 testing::Mock::VerifyAndClearExpectations(context_ptr); | 470 testing::Mock::VerifyAndClearExpectations(context_ptr); |
470 | 471 |
471 EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()); | 472 EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()); |
472 display_->Resize(gfx::Size(150, 150)); | 473 display_->Resize(gfx::Size(150, 150)); |
473 testing::Mock::VerifyAndClearExpectations(context_ptr); | 474 testing::Mock::VerifyAndClearExpectations(context_ptr); |
474 | 475 |
475 // Another resize without a swap doesn't need to finish. | 476 // Another resize without a swap doesn't need to finish. |
476 EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0); | 477 EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0); |
477 display_->Resize(gfx::Size(200, 200)); | 478 display_->Resize(gfx::Size(200, 200)); |
478 testing::Mock::VerifyAndClearExpectations(context_ptr); | 479 testing::Mock::VerifyAndClearExpectations(context_ptr); |
479 | 480 |
480 EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0); | 481 EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0); |
481 { | 482 { |
482 RenderPassList pass_list; | 483 RenderPassList pass_list; |
483 std::unique_ptr<RenderPass> pass = RenderPass::Create(); | 484 std::unique_ptr<RenderPass> pass = RenderPass::Create(); |
484 pass->output_rect = gfx::Rect(0, 0, 200, 200); | 485 pass->output_rect = gfx::Rect(0, 0, 200, 200); |
485 pass->damage_rect = gfx::Rect(10, 10, 1, 1); | 486 pass->damage_rect = gfx::Rect(10, 10, 1, 1); |
486 pass->id = RenderPassId(1, 1); | 487 pass->id = RenderPassId(1, 1); |
487 pass_list.push_back(std::move(pass)); | 488 pass_list.push_back(std::move(pass)); |
488 | 489 |
489 SubmitCompositorFrame(&pass_list, surface_id); | 490 SubmitCompositorFrame(&pass_list, local_frame_id); |
490 } | 491 } |
491 | 492 |
492 display_->DrawAndSwap(); | 493 display_->DrawAndSwap(); |
493 | 494 |
494 testing::Mock::VerifyAndClearExpectations(context_ptr); | 495 testing::Mock::VerifyAndClearExpectations(context_ptr); |
495 | 496 |
496 EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()); | 497 EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()); |
497 display_->Resize(gfx::Size(250, 250)); | 498 display_->Resize(gfx::Size(250, 250)); |
498 testing::Mock::VerifyAndClearExpectations(context_ptr); | 499 testing::Mock::VerifyAndClearExpectations(context_ptr); |
499 | 500 |
500 factory_.Destroy(surface_id); | 501 factory_.Destroy(local_frame_id); |
501 } | 502 } |
502 | 503 |
503 } // namespace | 504 } // namespace |
504 } // namespace cc | 505 } // namespace cc |
OLD | NEW |