src/ui/gfx/ozone/impl/hardware_display_controller_ozone_unittest.cc

   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 }