OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 "testing/gtest/include/gtest/gtest.h" | 5 #include "testing/gtest/include/gtest/gtest.h" |
6 #include "ui/gfx/ozone/impl/drm_skbitmap_ozone.h" | 6 #include "ui/gfx/ozone/impl/drm_skbitmap_ozone.h" |
7 #include "ui/gfx/ozone/impl/drm_wrapper_ozone.h" | 7 #include "ui/gfx/ozone/impl/drm_wrapper_ozone.h" |
8 #include "ui/gfx/ozone/impl/hardware_display_controller_ozone.h" | 8 #include "ui/gfx/ozone/impl/hardware_display_controller_ozone.h" |
9 #include "ui/gfx/ozone/impl/software_surface_ozone.h" | 9 #include "ui/gfx/ozone/impl/software_surface_ozone.h" |
10 | 10 |
(...skipping 181 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
192 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); | 192 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); |
193 | 193 |
194 EXPECT_EQ(1, drm_->get_get_crtc_call_count()); | 194 EXPECT_EQ(1, drm_->get_get_crtc_call_count()); |
195 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::UNINITIALIZED, | 195 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::UNINITIALIZED, |
196 controller_->get_state()); | 196 controller_->get_state()); |
197 } | 197 } |
198 | 198 |
199 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateAfterSurfaceIsBound) { | 199 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateAfterSurfaceIsBound) { |
200 controller_->SetControllerInfo( | 200 controller_->SetControllerInfo( |
201 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); | 201 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); |
202 gfx::SoftwareSurfaceOzone* surface = | 202 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( |
203 new MockSoftwareSurfaceOzone(controller_.get()); | 203 new MockSoftwareSurfaceOzone(controller_.get())); |
204 | 204 |
205 EXPECT_TRUE(surface->Initialize()); | 205 EXPECT_TRUE(surface->Initialize()); |
206 EXPECT_TRUE(controller_->BindSurfaceToController(surface)); | 206 EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass())); |
207 | 207 |
208 EXPECT_EQ(2, drm_->get_add_framebuffer_call_count()); | 208 EXPECT_EQ(2, drm_->get_add_framebuffer_call_count()); |
209 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::SURFACE_INITIALIZED, | 209 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::SURFACE_INITIALIZED, |
210 controller_->get_state()); | 210 controller_->get_state()); |
211 } | 211 } |
212 | 212 |
213 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateIfBindingFails) { | 213 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateIfBindingFails) { |
214 drm_->set_add_framebuffer_expectation(false); | 214 drm_->set_add_framebuffer_expectation(false); |
215 | 215 |
216 controller_->SetControllerInfo( | 216 controller_->SetControllerInfo( |
217 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); | 217 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); |
218 gfx::SoftwareSurfaceOzone* surface = | 218 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( |
219 new MockSoftwareSurfaceOzone(controller_.get()); | 219 new MockSoftwareSurfaceOzone(controller_.get())); |
220 | 220 |
221 EXPECT_TRUE(surface->Initialize()); | 221 EXPECT_TRUE(surface->Initialize()); |
222 EXPECT_FALSE(controller_->BindSurfaceToController(surface)); | 222 EXPECT_FALSE(controller_->BindSurfaceToController(surface.Pass())); |
223 | 223 |
224 EXPECT_EQ(1, drm_->get_add_framebuffer_call_count()); | 224 EXPECT_EQ(1, drm_->get_add_framebuffer_call_count()); |
225 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::FAILED, | 225 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::FAILED, |
226 controller_->get_state()); | 226 controller_->get_state()); |
227 | |
228 // Normally the controller would take ownership, but we failed to bind, so we | |
229 // need to clean up. | |
230 delete surface; | |
231 } | 227 } |
232 | 228 |
233 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateAfterPageFlip) { | 229 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateAfterPageFlip) { |
234 controller_->SetControllerInfo( | 230 controller_->SetControllerInfo( |
235 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); | 231 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); |
236 gfx::SoftwareSurfaceOzone* surface = | 232 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( |
237 new MockSoftwareSurfaceOzone(controller_.get()); | 233 new MockSoftwareSurfaceOzone(controller_.get())); |
238 | 234 |
239 EXPECT_TRUE(surface->Initialize()); | 235 EXPECT_TRUE(surface->Initialize()); |
240 EXPECT_TRUE(controller_->BindSurfaceToController(surface)); | 236 EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass())); |
241 | 237 |
242 controller_->SchedulePageFlip(); | 238 controller_->SchedulePageFlip(); |
243 | 239 |
244 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::INITIALIZED, | 240 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::INITIALIZED, |
245 controller_->get_state()); | 241 controller_->get_state()); |
246 } | 242 } |
247 | 243 |
248 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateIfModesetFails) { | 244 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateIfModesetFails) { |
249 drm_->set_set_crtc_expectation(false); | 245 drm_->set_set_crtc_expectation(false); |
250 | 246 |
251 controller_->SetControllerInfo( | 247 controller_->SetControllerInfo( |
252 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); | 248 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); |
253 gfx::SoftwareSurfaceOzone* surface = | 249 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( |
254 new MockSoftwareSurfaceOzone(controller_.get()); | 250 new MockSoftwareSurfaceOzone(controller_.get())); |
255 | 251 |
256 EXPECT_TRUE(surface->Initialize()); | 252 EXPECT_TRUE(surface->Initialize()); |
257 EXPECT_TRUE(controller_->BindSurfaceToController(surface)); | 253 EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass())); |
258 | 254 |
259 controller_->SchedulePageFlip(); | 255 controller_->SchedulePageFlip(); |
260 | 256 |
261 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::FAILED, | 257 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::FAILED, |
262 controller_->get_state()); | 258 controller_->get_state()); |
263 } | 259 } |
264 | 260 |
265 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateIfPageFlipFails) { | 261 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateIfPageFlipFails) { |
266 drm_->set_page_flip_expectation(false); | 262 drm_->set_page_flip_expectation(false); |
267 | 263 |
268 controller_->SetControllerInfo( | 264 controller_->SetControllerInfo( |
269 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); | 265 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); |
270 gfx::SoftwareSurfaceOzone* surface = | 266 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( |
271 new MockSoftwareSurfaceOzone(controller_.get()); | 267 new MockSoftwareSurfaceOzone(controller_.get())); |
272 | 268 |
273 EXPECT_TRUE(surface->Initialize()); | 269 EXPECT_TRUE(surface->Initialize()); |
274 EXPECT_TRUE(controller_->BindSurfaceToController(surface)); | 270 EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass())); |
275 | 271 |
276 controller_->SchedulePageFlip(); | 272 controller_->SchedulePageFlip(); |
277 | 273 |
278 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::FAILED, | 274 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::FAILED, |
279 controller_->get_state()); | 275 controller_->get_state()); |
280 } | 276 } |
281 | 277 |
282 TEST_F(HardwareDisplayControllerOzoneTest, CheckProperDestruction) { | 278 TEST_F(HardwareDisplayControllerOzoneTest, CheckProperDestruction) { |
283 controller_->SetControllerInfo( | 279 controller_->SetControllerInfo( |
284 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); | 280 drm_.get(), kConnectorId, kCrtcId, kDefaultMode); |
285 gfx::SoftwareSurfaceOzone* surface = | 281 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( |
286 new MockSoftwareSurfaceOzone(controller_.get()); | 282 new MockSoftwareSurfaceOzone(controller_.get())); |
287 | 283 |
288 EXPECT_TRUE(surface->Initialize()); | 284 EXPECT_TRUE(surface->Initialize()); |
289 EXPECT_TRUE(controller_->BindSurfaceToController(surface)); | 285 EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass())); |
290 | 286 |
291 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::SURFACE_INITIALIZED, | 287 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::SURFACE_INITIALIZED, |
292 controller_->get_state()); | 288 controller_->get_state()); |
293 | 289 |
294 controller_.reset(); | 290 controller_.reset(); |
295 | 291 |
296 EXPECT_EQ(2, drm_->get_remove_framebuffer_call_count()); | 292 EXPECT_EQ(2, drm_->get_remove_framebuffer_call_count()); |
297 EXPECT_EQ(1, drm_->get_restore_crtc_call_count()); | 293 EXPECT_EQ(1, drm_->get_restore_crtc_call_count()); |
298 EXPECT_EQ(1, drm_->get_free_crtc_call_count()); | 294 EXPECT_EQ(1, drm_->get_free_crtc_call_count()); |
299 } | 295 } |
OLD | NEW |