| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "testing/gtest/include/gtest/gtest.h" | |
| 6 #include "ui/gfx/ozone/impl/drm_skbitmap_ozone.h" | |
| 7 #include "ui/gfx/ozone/impl/drm_wrapper_ozone.h" | |
| 8 #include "ui/gfx/ozone/impl/hardware_display_controller_ozone.h" | |
| 9 #include "ui/gfx/ozone/impl/software_surface_ozone.h" | |
| 10 | |
| 11 namespace { | |
| 12 | |
| 13 // Create a basic mode for a 6x4 screen. | |
| 14 const drmModeModeInfo kDefaultMode = | |
| 15 {0, 6, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, {'\0'}}; | |
| 16 | |
| 17 // Mock file descriptor ID. | |
| 18 const int kFd = 3; | |
| 19 | |
| 20 // Mock connector ID. | |
| 21 const uint32_t kConnectorId = 1; | |
| 22 | |
| 23 // Mock CRTC ID. | |
| 24 const uint32_t kCrtcId = 1; | |
| 25 | |
| 26 const uint32_t kDPMSPropertyId = 1; | |
| 27 | |
| 28 // The real DrmWrapper makes actual DRM calls which we can't use in unit tests. | |
| 29 class MockDrmWrapperOzone : public gfx::DrmWrapperOzone { | |
| 30 public: | |
| 31 MockDrmWrapperOzone(int fd) : DrmWrapperOzone(""), | |
| 32 get_crtc_call_count_(0), | |
| 33 free_crtc_call_count_(0), | |
| 34 restore_crtc_call_count_(0), | |
| 35 add_framebuffer_call_count_(0), | |
| 36 remove_framebuffer_call_count_(0), | |
| 37 set_crtc_expectation_(true), | |
| 38 add_framebuffer_expectation_(true), | |
| 39 page_flip_expectation_(true) { | |
| 40 fd_ = fd; | |
| 41 } | |
| 42 | |
| 43 virtual ~MockDrmWrapperOzone() { fd_ = -1; } | |
| 44 | |
| 45 virtual drmModeCrtc* GetCrtc(uint32_t crtc_id) OVERRIDE { | |
| 46 get_crtc_call_count_++; | |
| 47 return new drmModeCrtc; | |
| 48 } | |
| 49 | |
| 50 virtual void FreeCrtc(drmModeCrtc* crtc) OVERRIDE { | |
| 51 free_crtc_call_count_++; | |
| 52 delete crtc; | |
| 53 } | |
| 54 | |
| 55 virtual bool SetCrtc(uint32_t crtc_id, | |
| 56 uint32_t framebuffer, | |
| 57 uint32_t* connectors, | |
| 58 drmModeModeInfo* mode) OVERRIDE { | |
| 59 return set_crtc_expectation_; | |
| 60 } | |
| 61 | |
| 62 virtual bool SetCrtc(drmModeCrtc* crtc, uint32_t* connectors) OVERRIDE { | |
| 63 restore_crtc_call_count_++; | |
| 64 return true; | |
| 65 } | |
| 66 | |
| 67 virtual bool AddFramebuffer(const drmModeModeInfo& mode, | |
| 68 uint8_t depth, | |
| 69 uint8_t bpp, | |
| 70 uint32_t stride, | |
| 71 uint32_t handle, | |
| 72 uint32_t* framebuffer) OVERRIDE { | |
| 73 add_framebuffer_call_count_++; | |
| 74 return add_framebuffer_expectation_; | |
| 75 } | |
| 76 | |
| 77 virtual bool RemoveFramebuffer(uint32_t framebuffer) OVERRIDE { | |
| 78 remove_framebuffer_call_count_++; | |
| 79 return true; | |
| 80 } | |
| 81 | |
| 82 virtual bool PageFlip(uint32_t crtc_id, | |
| 83 uint32_t framebuffer, | |
| 84 void* data) OVERRIDE { | |
| 85 return page_flip_expectation_; | |
| 86 } | |
| 87 | |
| 88 virtual bool ConnectorSetProperty(uint32_t connector_id, | |
| 89 uint32_t property_id, | |
| 90 uint64_t value) OVERRIDE { return true; } | |
| 91 | |
| 92 int get_get_crtc_call_count() const { | |
| 93 return get_crtc_call_count_; | |
| 94 } | |
| 95 | |
| 96 int get_free_crtc_call_count() const { | |
| 97 return free_crtc_call_count_; | |
| 98 } | |
| 99 | |
| 100 int get_restore_crtc_call_count() const { | |
| 101 return restore_crtc_call_count_; | |
| 102 } | |
| 103 | |
| 104 int get_add_framebuffer_call_count() const { | |
| 105 return add_framebuffer_call_count_; | |
| 106 } | |
| 107 | |
| 108 int get_remove_framebuffer_call_count() const { | |
| 109 return remove_framebuffer_call_count_; | |
| 110 } | |
| 111 | |
| 112 void set_set_crtc_expectation(bool state) { | |
| 113 set_crtc_expectation_ = state; | |
| 114 } | |
| 115 | |
| 116 void set_add_framebuffer_expectation(bool state) { | |
| 117 add_framebuffer_expectation_ = state; | |
| 118 } | |
| 119 | |
| 120 void set_page_flip_expectation(bool state) { | |
| 121 page_flip_expectation_ = state; | |
| 122 } | |
| 123 | |
| 124 private: | |
| 125 int get_crtc_call_count_; | |
| 126 int free_crtc_call_count_; | |
| 127 int restore_crtc_call_count_; | |
| 128 int add_framebuffer_call_count_; | |
| 129 int remove_framebuffer_call_count_; | |
| 130 | |
| 131 bool set_crtc_expectation_; | |
| 132 bool add_framebuffer_expectation_; | |
| 133 bool page_flip_expectation_; | |
| 134 | |
| 135 DISALLOW_COPY_AND_ASSIGN(MockDrmWrapperOzone); | |
| 136 }; | |
| 137 | |
| 138 class MockDrmSkBitmapOzone : public gfx::DrmSkBitmapOzone { | |
| 139 public: | |
| 140 MockDrmSkBitmapOzone(int fd) : DrmSkBitmapOzone(fd) {} | |
| 141 virtual ~MockDrmSkBitmapOzone() {} | |
| 142 | |
| 143 virtual bool Initialize() OVERRIDE { | |
| 144 return allocPixels(); | |
| 145 } | |
| 146 private: | |
| 147 DISALLOW_COPY_AND_ASSIGN(MockDrmSkBitmapOzone); | |
| 148 }; | |
| 149 | |
| 150 class MockSoftwareSurfaceOzone : public gfx::SoftwareSurfaceOzone { | |
| 151 public: | |
| 152 MockSoftwareSurfaceOzone(gfx::HardwareDisplayControllerOzone* controller) | |
| 153 : SoftwareSurfaceOzone(controller) {} | |
| 154 virtual ~MockSoftwareSurfaceOzone() {} | |
| 155 | |
| 156 private: | |
| 157 virtual gfx::DrmSkBitmapOzone* CreateBuffer() OVERRIDE { | |
| 158 return new MockDrmSkBitmapOzone(kFd); | |
| 159 } | |
| 160 DISALLOW_COPY_AND_ASSIGN(MockSoftwareSurfaceOzone); | |
| 161 }; | |
| 162 | |
| 163 } // namespace | |
| 164 | |
| 165 class HardwareDisplayControllerOzoneTest : public testing::Test { | |
| 166 public: | |
| 167 HardwareDisplayControllerOzoneTest() {} | |
| 168 virtual ~HardwareDisplayControllerOzoneTest() {} | |
| 169 | |
| 170 virtual void SetUp() OVERRIDE; | |
| 171 virtual void TearDown() OVERRIDE; | |
| 172 protected: | |
| 173 scoped_ptr<gfx::HardwareDisplayControllerOzone> controller_; | |
| 174 scoped_ptr<MockDrmWrapperOzone> drm_; | |
| 175 | |
| 176 private: | |
| 177 DISALLOW_COPY_AND_ASSIGN(HardwareDisplayControllerOzoneTest); | |
| 178 }; | |
| 179 | |
| 180 void HardwareDisplayControllerOzoneTest::SetUp() { | |
| 181 controller_.reset(new gfx::HardwareDisplayControllerOzone()); | |
| 182 drm_.reset(new MockDrmWrapperOzone(kFd)); | |
| 183 } | |
| 184 | |
| 185 void HardwareDisplayControllerOzoneTest::TearDown() { | |
| 186 controller_.reset(); | |
| 187 drm_.reset(); | |
| 188 } | |
| 189 | |
| 190 TEST_F(HardwareDisplayControllerOzoneTest, CheckInitialState) { | |
| 191 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::UNASSOCIATED, | |
| 192 controller_->get_state()); | |
| 193 } | |
| 194 | |
| 195 TEST_F(HardwareDisplayControllerOzoneTest, | |
| 196 CheckStateAfterControllerIsInitialized) { | |
| 197 controller_->SetControllerInfo( | |
| 198 drm_.get(), kConnectorId, kCrtcId, kDPMSPropertyId, kDefaultMode); | |
| 199 | |
| 200 EXPECT_EQ(1, drm_->get_get_crtc_call_count()); | |
| 201 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::UNINITIALIZED, | |
| 202 controller_->get_state()); | |
| 203 } | |
| 204 | |
| 205 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateAfterSurfaceIsBound) { | |
| 206 controller_->SetControllerInfo( | |
| 207 drm_.get(), kConnectorId, kCrtcId, kDPMSPropertyId, kDefaultMode); | |
| 208 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( | |
| 209 new MockSoftwareSurfaceOzone(controller_.get())); | |
| 210 | |
| 211 EXPECT_TRUE(surface->Initialize()); | |
| 212 EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass())); | |
| 213 | |
| 214 EXPECT_EQ(2, drm_->get_add_framebuffer_call_count()); | |
| 215 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::SURFACE_INITIALIZED, | |
| 216 controller_->get_state()); | |
| 217 } | |
| 218 | |
| 219 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateIfBindingFails) { | |
| 220 drm_->set_add_framebuffer_expectation(false); | |
| 221 | |
| 222 controller_->SetControllerInfo( | |
| 223 drm_.get(), kConnectorId, kCrtcId, kDPMSPropertyId, kDefaultMode); | |
| 224 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( | |
| 225 new MockSoftwareSurfaceOzone(controller_.get())); | |
| 226 | |
| 227 EXPECT_TRUE(surface->Initialize()); | |
| 228 EXPECT_FALSE(controller_->BindSurfaceToController(surface.Pass())); | |
| 229 | |
| 230 EXPECT_EQ(1, drm_->get_add_framebuffer_call_count()); | |
| 231 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::FAILED, | |
| 232 controller_->get_state()); | |
| 233 } | |
| 234 | |
| 235 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateAfterPageFlip) { | |
| 236 controller_->SetControllerInfo( | |
| 237 drm_.get(), kConnectorId, kCrtcId, kDPMSPropertyId, kDefaultMode); | |
| 238 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( | |
| 239 new MockSoftwareSurfaceOzone(controller_.get())); | |
| 240 | |
| 241 EXPECT_TRUE(surface->Initialize()); | |
| 242 EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass())); | |
| 243 | |
| 244 controller_->SchedulePageFlip(); | |
| 245 | |
| 246 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::INITIALIZED, | |
| 247 controller_->get_state()); | |
| 248 } | |
| 249 | |
| 250 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateIfModesetFails) { | |
| 251 drm_->set_set_crtc_expectation(false); | |
| 252 | |
| 253 controller_->SetControllerInfo( | |
| 254 drm_.get(), kConnectorId, kCrtcId, kDPMSPropertyId, kDefaultMode); | |
| 255 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( | |
| 256 new MockSoftwareSurfaceOzone(controller_.get())); | |
| 257 | |
| 258 EXPECT_TRUE(surface->Initialize()); | |
| 259 EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass())); | |
| 260 | |
| 261 controller_->SchedulePageFlip(); | |
| 262 | |
| 263 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::FAILED, | |
| 264 controller_->get_state()); | |
| 265 } | |
| 266 | |
| 267 TEST_F(HardwareDisplayControllerOzoneTest, CheckStateIfPageFlipFails) { | |
| 268 drm_->set_page_flip_expectation(false); | |
| 269 | |
| 270 controller_->SetControllerInfo( | |
| 271 drm_.get(), kConnectorId, kCrtcId, kDPMSPropertyId, kDefaultMode); | |
| 272 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( | |
| 273 new MockSoftwareSurfaceOzone(controller_.get())); | |
| 274 | |
| 275 EXPECT_TRUE(surface->Initialize()); | |
| 276 EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass())); | |
| 277 | |
| 278 controller_->SchedulePageFlip(); | |
| 279 | |
| 280 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::FAILED, | |
| 281 controller_->get_state()); | |
| 282 } | |
| 283 | |
| 284 TEST_F(HardwareDisplayControllerOzoneTest, CheckProperDestruction) { | |
| 285 controller_->SetControllerInfo( | |
| 286 drm_.get(), kConnectorId, kCrtcId, kDPMSPropertyId, kDefaultMode); | |
| 287 scoped_ptr<gfx::SoftwareSurfaceOzone> surface( | |
| 288 new MockSoftwareSurfaceOzone(controller_.get())); | |
| 289 | |
| 290 EXPECT_TRUE(surface->Initialize()); | |
| 291 EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass())); | |
| 292 | |
| 293 EXPECT_EQ(gfx::HardwareDisplayControllerOzone::SURFACE_INITIALIZED, | |
| 294 controller_->get_state()); | |
| 295 | |
| 296 controller_.reset(); | |
| 297 | |
| 298 EXPECT_EQ(2, drm_->get_remove_framebuffer_call_count()); | |
| 299 EXPECT_EQ(1, drm_->get_restore_crtc_call_count()); | |
| 300 EXPECT_EQ(1, drm_->get_free_crtc_call_count()); | |
| 301 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 49303002:
[Ozone] Rename software implementation files to use Dri prefix (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src