| 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 |