src/ui/gfx/ozone/impl/software_surface_factory_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 "base/memory/scoped_ptr.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "testing/gtest/include/gtest/gtest.h"
   8 #include "ui/gfx/ozone/impl/drm_skbitmap_ozone.h"
   9 #include "ui/gfx/ozone/impl/drm_wrapper_ozone.h"
  10 #include "ui/gfx/ozone/impl/hardware_display_controller_ozone.h"
  11 #include "ui/gfx/ozone/impl/software_surface_factory_ozone.h"
  12 #include "ui/gfx/ozone/impl/software_surface_ozone.h"
  13 #include "ui/gfx/ozone/surface_factory_ozone.h"
  14
  15 namespace {
  16
  17 const drmModeModeInfo kDefaultMode =
  18     {0, 6, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, {'\0'}};
  19
  20 // Mock file descriptor ID.
  21 const int kFd = 3;
  22
  23 // Mock connector ID.
  24 const uint32_t kConnectorId = 1;
  25
  26 // Mock CRTC ID.
  27 const uint32_t kCrtcId = 1;
  28
  29 const uint32_t kDPMSPropertyId = 1;
  30
  31 const gfx::AcceleratedWidget kDefaultWidgetHandle = 1;
  32
  33 // The real DrmWrapper makes actual DRM calls which we can't use in unit tests.
  34 class MockDrmWrapperOzone : public gfx::DrmWrapperOzone {
  35  public:
  36   MockDrmWrapperOzone(int fd) : DrmWrapperOzone(""),
  37                                 add_framebuffer_expectation_(true),
  38                                 page_flip_expectation_(true) {
  39     fd_ = fd;
  40   }
  41
  42   virtual ~MockDrmWrapperOzone() { fd_ = -1; }
  43
  44   virtual drmModeCrtc* GetCrtc(uint32_t crtc_id) OVERRIDE {
  45     return new drmModeCrtc;
  46   }
  47
  48   virtual void FreeCrtc(drmModeCrtc* crtc) OVERRIDE {
  49     delete crtc;
  50   }
  51
  52   virtual bool SetCrtc(uint32_t crtc_id,
  53                        uint32_t framebuffer,
  54                        uint32_t* connectors,
  55                        drmModeModeInfo* mode) OVERRIDE {
  56     return true;
  57   }
  58
  59   virtual bool SetCrtc(drmModeCrtc* crtc, uint32_t* connectors) OVERRIDE {
  60     return true;
  61   }
  62
  63   virtual bool AddFramebuffer(const drmModeModeInfo& mode,
  64                               uint8_t depth,
  65                               uint8_t bpp,
  66                               uint32_t stride,
  67                               uint32_t handle,
  68                               uint32_t* framebuffer) OVERRIDE {
  69     return add_framebuffer_expectation_;
  70   }
  71
  72   virtual bool RemoveFramebuffer(uint32_t framebuffer) OVERRIDE { return true; }
  73
  74   virtual bool PageFlip(uint32_t crtc_id,
  75                         uint32_t framebuffer,
  76                         void* data) OVERRIDE {
  77     static_cast<gfx::HardwareDisplayControllerOzone*>(data)->get_surface()
  78         ->SwapBuffers();
  79     return page_flip_expectation_;
  80   }
  81
  82   virtual bool ConnectorSetProperty(uint32_t connector_id,
  83                                     uint32_t property_id,
  84                                     uint64_t value) OVERRIDE { return true; }
  85
  86   void set_add_framebuffer_expectation(bool state) {
  87     add_framebuffer_expectation_ = state;
  88   }
  89
  90   void set_page_flip_expectation(bool state) {
  91     page_flip_expectation_ = state;
  92   }
  93
  94  private:
  95   bool add_framebuffer_expectation_;
  96   bool page_flip_expectation_;
  97
  98   DISALLOW_COPY_AND_ASSIGN(MockDrmWrapperOzone);
  99 };
 100
 101 class MockDrmSkBitmapOzone : public gfx::DrmSkBitmapOzone {
 102  public:
 103   MockDrmSkBitmapOzone() : DrmSkBitmapOzone(kFd) {}
 104   virtual ~MockDrmSkBitmapOzone() {}
 105
 106   virtual bool Initialize() OVERRIDE {
 107     allocPixels();
 108     eraseColor(SK_ColorBLACK);
 109     return true;
 110   }
 111
 112  private:
 113   DISALLOW_COPY_AND_ASSIGN(MockDrmSkBitmapOzone);
 114 };
 115
 116 class MockSoftwareSurfaceOzone : public gfx::SoftwareSurfaceOzone {
 117  public:
 118   MockSoftwareSurfaceOzone(gfx::HardwareDisplayControllerOzone* controller)
 119       : SoftwareSurfaceOzone(controller) {}
 120   virtual ~MockSoftwareSurfaceOzone() {}
 121
 122  private:
 123   virtual gfx::DrmSkBitmapOzone* CreateBuffer() OVERRIDE {
 124     return new MockDrmSkBitmapOzone();
 125   }
 126
 127   DISALLOW_COPY_AND_ASSIGN(MockSoftwareSurfaceOzone);
 128 };
 129
 130 // SSFO would normally allocate DRM resources. We can't rely on having a DRM
 131 // backend to allocate and display our buffers. Thus, we replace these
 132 // resources with stubs. For DRM calls, we simply use stubs that do nothing and
 133 // for buffers we use the default SkBitmap allocator.
 134 class MockSoftwareSurfaceFactoryOzone
 135     : public gfx::SoftwareSurfaceFactoryOzone {
 136  public:
 137   MockSoftwareSurfaceFactoryOzone()
 138       : SoftwareSurfaceFactoryOzone(),
 139         mock_drm_(NULL),
 140         drm_wrapper_expectation_(true),
 141         initialize_controller_expectation_(true) {}
 142   virtual ~MockSoftwareSurfaceFactoryOzone() {};
 143
 144   void set_drm_wrapper_expectation(bool state) {
 145     drm_wrapper_expectation_ = state;
 146   }
 147
 148   void set_initialize_controller_expectation(bool state) {
 149     initialize_controller_expectation_ = state;
 150   }
 151
 152   MockDrmWrapperOzone* get_drm() const {
 153     return mock_drm_;
 154   }
 155
 156  private:
 157   virtual gfx::SoftwareSurfaceOzone* CreateSurface(
 158       gfx::HardwareDisplayControllerOzone* controller) OVERRIDE {
 159     return new MockSoftwareSurfaceOzone(controller);
 160   }
 161
 162   virtual gfx::DrmWrapperOzone* CreateWrapper() OVERRIDE {
 163     if (drm_wrapper_expectation_)
 164       mock_drm_ = new MockDrmWrapperOzone(kFd);
 165     else
 166       mock_drm_ = new MockDrmWrapperOzone(-1);
 167
 168     return mock_drm_;
 169   }
 170
 171   // Normally we'd use DRM to figure out the controller configuration. But we
 172   // can't use DRM in unit tests, so we just create a fake configuration.
 173   virtual bool InitializeControllerForPrimaryDisplay(
 174       gfx::DrmWrapperOzone* drm,
 175       gfx::HardwareDisplayControllerOzone* controller) OVERRIDE {
 176     if (initialize_controller_expectation_) {
 177       controller->SetControllerInfo(drm,
 178                                     kConnectorId,
 179                                     kCrtcId,
 180                                     kDPMSPropertyId,
 181                                     kDefaultMode);
 182       return true;
 183     } else {
 184       return false;
 185     }
 186   }
 187
 188   virtual void WaitForPageFlipEvent(int fd) OVERRIDE {}
 189
 190   MockDrmWrapperOzone* mock_drm_;
 191   bool drm_wrapper_expectation_;
 192   bool initialize_controller_expectation_;
 193
 194   DISALLOW_COPY_AND_ASSIGN(MockSoftwareSurfaceFactoryOzone);
 195 };
 196
 197 }  // namespace
 198
 199 class SoftwareSurfaceFactoryOzoneTest : public testing::Test {
 200  public:
 201   SoftwareSurfaceFactoryOzoneTest() {}
 202
 203   virtual void SetUp() OVERRIDE;
 204   virtual void TearDown() OVERRIDE;
 205  protected:
 206   scoped_ptr<base::MessageLoop> message_loop_;
 207   scoped_ptr<MockSoftwareSurfaceFactoryOzone> factory_;
 208
 209  private:
 210   DISALLOW_COPY_AND_ASSIGN(SoftwareSurfaceFactoryOzoneTest);
 211 };
 212
 213 void SoftwareSurfaceFactoryOzoneTest::SetUp() {
 214   message_loop_.reset(new base::MessageLoop(base::MessageLoop::TYPE_UI));
 215   factory_.reset(new MockSoftwareSurfaceFactoryOzone());
 216 }
 217
 218 void SoftwareSurfaceFactoryOzoneTest::TearDown() {
 219   factory_.reset();
 220   message_loop_.reset();
 221 }
 222
 223 TEST_F(SoftwareSurfaceFactoryOzoneTest, FailInitialization) {
 224   factory_->set_drm_wrapper_expectation(false);
 225
 226   EXPECT_EQ(gfx::SurfaceFactoryOzone::FAILED, factory_->InitializeHardware());
 227 }
 228
 229 TEST_F(SoftwareSurfaceFactoryOzoneTest, SuccessfulInitialization) {
 230   EXPECT_EQ(gfx::SurfaceFactoryOzone::INITIALIZED,
 231             factory_->InitializeHardware());
 232 }
 233
 234 TEST_F(SoftwareSurfaceFactoryOzoneTest, FailSurfaceInitialization) {
 235   factory_->set_initialize_controller_expectation(false);
 236
 237   EXPECT_EQ(gfx::SurfaceFactoryOzone::INITIALIZED,
 238             factory_->InitializeHardware());
 239
 240   gfx::AcceleratedWidget w = factory_->GetAcceleratedWidget();
 241   EXPECT_EQ(kDefaultWidgetHandle, w);
 242
 243   EXPECT_EQ(gfx::kNullAcceleratedWidget, factory_->RealizeAcceleratedWidget(w));
 244 }
 245
 246 TEST_F(SoftwareSurfaceFactoryOzoneTest, FailBindingSurfaceToController) {
 247   EXPECT_EQ(gfx::SurfaceFactoryOzone::INITIALIZED,
 248             factory_->InitializeHardware());
 249
 250   factory_->get_drm()->set_add_framebuffer_expectation(false);
 251
 252   gfx::AcceleratedWidget w = factory_->GetAcceleratedWidget();
 253   EXPECT_EQ(kDefaultWidgetHandle, w);
 254
 255   EXPECT_EQ(gfx::kNullAcceleratedWidget, factory_->RealizeAcceleratedWidget(w));
 256 }
 257
 258 TEST_F(SoftwareSurfaceFactoryOzoneTest, SuccessfulWidgetRealization) {
 259   EXPECT_EQ(gfx::SurfaceFactoryOzone::INITIALIZED,
 260             factory_->InitializeHardware());
 261
 262   gfx::AcceleratedWidget w = factory_->GetAcceleratedWidget();
 263   EXPECT_EQ(kDefaultWidgetHandle, w);
 264
 265   EXPECT_NE(gfx::kNullAcceleratedWidget, factory_->RealizeAcceleratedWidget(w));
 266 }
 267
 268 TEST_F(SoftwareSurfaceFactoryOzoneTest, FailSchedulePageFlip) {
 269   EXPECT_EQ(gfx::SurfaceFactoryOzone::INITIALIZED,
 270             factory_->InitializeHardware());
 271
 272   factory_->get_drm()->set_page_flip_expectation(false);
 273
 274   gfx::AcceleratedWidget w = factory_->GetAcceleratedWidget();
 275   EXPECT_EQ(kDefaultWidgetHandle, w);
 276
 277   EXPECT_NE(gfx::kNullAcceleratedWidget, factory_->RealizeAcceleratedWidget(w));
 278
 279   EXPECT_FALSE(factory_->SchedulePageFlip(w));
 280 }
 281
 282 TEST_F(SoftwareSurfaceFactoryOzoneTest, SuccessfulSchedulePageFlip) {
 283   EXPECT_EQ(gfx::SurfaceFactoryOzone::INITIALIZED,
 284             factory_->InitializeHardware());
 285
 286   gfx::AcceleratedWidget w = factory_->GetAcceleratedWidget();
 287   EXPECT_EQ(kDefaultWidgetHandle, w);
 288
 289   EXPECT_NE(gfx::kNullAcceleratedWidget, factory_->RealizeAcceleratedWidget(w));
 290
 291   EXPECT_TRUE(factory_->SchedulePageFlip(w));
 292 }