ui/ozone/platform/drm/gpu/screen_manager_unittest.cc

   1 // Copyright 2014 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/ozone/platform/drm/gpu/crtc_controller.h"
   7 #include "ui/ozone/platform/drm/gpu/drm_buffer.h"
   8 #include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
   9 #include "ui/ozone/platform/drm/gpu/drm_window.h"
  10 #include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
  11 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
  12 #include "ui/ozone/platform/drm/test/mock_drm_device.h"
  13
  14 namespace {
  15
  16 // Create a basic mode for a 6x4 screen.
  17 const drmModeModeInfo kDefaultMode =
  18     {0, 6, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, {'\0'}};
  19
  20 const uint32_t kPrimaryCrtc = 1;
  21 const uint32_t kPrimaryConnector = 2;
  22 const uint32_t kSecondaryCrtc = 3;
  23 const uint32_t kSecondaryConnector = 4;
  24
  25 }  // namespace
  26
  27 class ScreenManagerTest : public testing::Test {
  28  public:
  29   ScreenManagerTest() {}
  30   ~ScreenManagerTest() override {}
  31
  32   gfx::Rect GetPrimaryBounds() const {
  33     return gfx::Rect(0, 0, kDefaultMode.hdisplay, kDefaultMode.vdisplay);
  34   }
  35
  36   // Secondary is in extended mode, right-of primary.
  37   gfx::Rect GetSecondaryBounds() const {
  38     return gfx::Rect(kDefaultMode.hdisplay, 0, kDefaultMode.hdisplay,
  39                      kDefaultMode.vdisplay);
  40   }
  41
  42   void SetUp() override {
  43     drm_ = new ui::MockDrmDevice();
  44     buffer_generator_.reset(new ui::DrmBufferGenerator());
  45     screen_manager_.reset(new ui::ScreenManager(buffer_generator_.get()));
  46   }
  47   void TearDown() override {
  48     screen_manager_.reset();
  49     drm_ = nullptr;
  50   }
  51
  52  protected:
  53   scoped_refptr<ui::MockDrmDevice> drm_;
  54   scoped_ptr<ui::DrmBufferGenerator> buffer_generator_;
  55   scoped_ptr<ui::ScreenManager> screen_manager_;
  56
  57  private:
  58   DISALLOW_COPY_AND_ASSIGN(ScreenManagerTest);
  59 };
  60
  61 TEST_F(ScreenManagerTest, CheckWithNoControllers) {
  62   EXPECT_FALSE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
  63 }
  64
  65 TEST_F(ScreenManagerTest, CheckWithValidController) {
  66   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
  67   screen_manager_->ConfigureDisplayController(
  68       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
  69       kDefaultMode);
  70   ui::HardwareDisplayController* controller =
  71       screen_manager_->GetDisplayController(GetPrimaryBounds());
  72
  73   EXPECT_TRUE(controller);
  74   EXPECT_TRUE(controller->HasCrtc(drm_, kPrimaryCrtc));
  75 }
  76
  77 TEST_F(ScreenManagerTest, CheckWithInvalidBounds) {
  78   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
  79   screen_manager_->ConfigureDisplayController(
  80       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
  81       kDefaultMode);
  82
  83   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
  84   EXPECT_FALSE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
  85 }
  86
  87 TEST_F(ScreenManagerTest, CheckForSecondValidController) {
  88   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
  89   screen_manager_->ConfigureDisplayController(
  90       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
  91       kDefaultMode);
  92   screen_manager_->AddDisplayController(drm_, kSecondaryCrtc,
  93                                         kSecondaryConnector);
  94   screen_manager_->ConfigureDisplayController(
  95       drm_, kSecondaryCrtc, kSecondaryConnector, GetSecondaryBounds().origin(),
  96       kDefaultMode);
  97
  98   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
  99   EXPECT_TRUE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 100 }
 101
 102 TEST_F(ScreenManagerTest, CheckControllerAfterItIsRemoved) {
 103   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 104   screen_manager_->ConfigureDisplayController(
 105       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 106       kDefaultMode);
 107   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
 108
 109   screen_manager_->RemoveDisplayController(drm_, kPrimaryCrtc);
 110   EXPECT_FALSE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
 111 }
 112
 113 TEST_F(ScreenManagerTest, CheckDuplicateConfiguration) {
 114   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 115   screen_manager_->ConfigureDisplayController(
 116       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 117       kDefaultMode);
 118   uint32_t framebuffer = drm_->current_framebuffer();
 119
 120   screen_manager_->ConfigureDisplayController(
 121       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 122       kDefaultMode);
 123
 124   // Should reuse existing framebuffer.
 125   EXPECT_EQ(framebuffer, drm_->current_framebuffer());
 126
 127   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
 128   EXPECT_FALSE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 129 }
 130
 131 TEST_F(ScreenManagerTest, CheckChangingMode) {
 132   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 133   screen_manager_->ConfigureDisplayController(
 134       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 135       kDefaultMode);
 136   drmModeModeInfo new_mode = kDefaultMode;
 137   new_mode.vdisplay = 10;
 138   screen_manager_->ConfigureDisplayController(
 139       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 140       new_mode);
 141
 142   gfx::Rect new_bounds(0, 0, new_mode.hdisplay, new_mode.vdisplay);
 143   EXPECT_TRUE(screen_manager_->GetDisplayController(new_bounds));
 144   EXPECT_FALSE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 145   drmModeModeInfo mode =
 146       screen_manager_->GetDisplayController(new_bounds)->get_mode();
 147   EXPECT_EQ(new_mode.vdisplay, mode.vdisplay);
 148   EXPECT_EQ(new_mode.hdisplay, mode.hdisplay);
 149 }
 150
 151 TEST_F(ScreenManagerTest, CheckForControllersInMirroredMode) {
 152   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 153   screen_manager_->ConfigureDisplayController(
 154       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 155       kDefaultMode);
 156   screen_manager_->AddDisplayController(drm_, kSecondaryCrtc,
 157                                         kSecondaryConnector);
 158   screen_manager_->ConfigureDisplayController(
 159       drm_, kSecondaryCrtc, kSecondaryConnector, GetPrimaryBounds().origin(),
 160       kDefaultMode);
 161
 162   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
 163   EXPECT_FALSE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 164 }
 165
 166 TEST_F(ScreenManagerTest, CheckMirrorModeTransitions) {
 167   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 168   screen_manager_->ConfigureDisplayController(
 169       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 170       kDefaultMode);
 171   screen_manager_->AddDisplayController(drm_, kSecondaryCrtc,
 172                                         kSecondaryConnector);
 173   screen_manager_->ConfigureDisplayController(
 174       drm_, kSecondaryCrtc, kSecondaryConnector, GetSecondaryBounds().origin(),
 175       kDefaultMode);
 176
 177   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
 178   EXPECT_TRUE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 179
 180   screen_manager_->ConfigureDisplayController(
 181       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 182       kDefaultMode);
 183   screen_manager_->ConfigureDisplayController(
 184       drm_, kSecondaryCrtc, kSecondaryConnector, GetPrimaryBounds().origin(),
 185       kDefaultMode);
 186   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
 187   EXPECT_FALSE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 188
 189   screen_manager_->ConfigureDisplayController(
 190       drm_, kPrimaryCrtc, kPrimaryConnector, GetSecondaryBounds().origin(),
 191       kDefaultMode);
 192   screen_manager_->ConfigureDisplayController(
 193       drm_, kSecondaryCrtc, kSecondaryConnector, GetPrimaryBounds().origin(),
 194       kDefaultMode);
 195   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
 196   EXPECT_TRUE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 197 }
 198
 199 TEST_F(ScreenManagerTest, MonitorGoneInMirrorMode) {
 200   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 201   screen_manager_->ConfigureDisplayController(
 202       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 203       kDefaultMode);
 204   screen_manager_->AddDisplayController(drm_, kSecondaryCrtc,
 205                                         kSecondaryConnector);
 206   screen_manager_->ConfigureDisplayController(
 207       drm_, kSecondaryCrtc, kSecondaryConnector, GetPrimaryBounds().origin(),
 208       kDefaultMode);
 209
 210   screen_manager_->RemoveDisplayController(drm_, kSecondaryCrtc);
 211   EXPECT_TRUE(screen_manager_->ConfigureDisplayController(
 212       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 213       kDefaultMode));
 214
 215   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
 216   EXPECT_FALSE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 217 }
 218
 219 TEST_F(ScreenManagerTest, DoNotEnterMirrorModeUnlessSameBounds) {
 220   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 221   screen_manager_->AddDisplayController(drm_, kSecondaryCrtc,
 222                                         kSecondaryConnector);
 223
 224   // Configure displays in extended mode.
 225   screen_manager_->ConfigureDisplayController(
 226       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 227       kDefaultMode);
 228   screen_manager_->ConfigureDisplayController(
 229       drm_, kSecondaryCrtc, kSecondaryConnector, GetSecondaryBounds().origin(),
 230       kDefaultMode);
 231
 232   drmModeModeInfo new_mode = kDefaultMode;
 233   new_mode.vdisplay = 10;
 234   // Shouldn't enter mirror mode unless the display bounds are the same.
 235   screen_manager_->ConfigureDisplayController(
 236       drm_, kSecondaryCrtc, kSecondaryConnector, GetPrimaryBounds().origin(),
 237       new_mode);
 238
 239   EXPECT_FALSE(
 240       screen_manager_->GetDisplayController(GetPrimaryBounds())->IsMirrored());
 241 }
 242
 243 TEST_F(ScreenManagerTest, ReuseFramebufferIfDisabledThenReEnabled) {
 244   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 245   screen_manager_->ConfigureDisplayController(
 246       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 247       kDefaultMode);
 248   uint32_t framebuffer = drm_->current_framebuffer();
 249
 250   screen_manager_->DisableDisplayController(drm_, kPrimaryCrtc);
 251   EXPECT_EQ(0u, drm_->current_framebuffer());
 252
 253   screen_manager_->ConfigureDisplayController(
 254       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 255       kDefaultMode);
 256
 257   // Should reuse existing framebuffer.
 258   EXPECT_EQ(framebuffer, drm_->current_framebuffer());
 259 }
 260
 261 TEST_F(ScreenManagerTest, CheckMirrorModeAfterBeginReEnabled) {
 262   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 263   screen_manager_->ConfigureDisplayController(
 264       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 265       kDefaultMode);
 266   screen_manager_->DisableDisplayController(drm_, kPrimaryCrtc);
 267
 268   screen_manager_->AddDisplayController(drm_, kSecondaryCrtc,
 269                                         kSecondaryConnector);
 270   screen_manager_->ConfigureDisplayController(
 271       drm_, kSecondaryCrtc, kSecondaryConnector, GetPrimaryBounds().origin(),
 272       kDefaultMode);
 273
 274   ui::HardwareDisplayController* controller =
 275       screen_manager_->GetDisplayController(GetPrimaryBounds());
 276   EXPECT_TRUE(controller);
 277   EXPECT_FALSE(controller->IsMirrored());
 278
 279   screen_manager_->ConfigureDisplayController(
 280       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 281       kDefaultMode);
 282   EXPECT_TRUE(controller);
 283   EXPECT_TRUE(controller->IsMirrored());
 284 }
 285
 286 TEST_F(ScreenManagerTest,
 287        CheckProperConfigurationWithDifferentDeviceAndSameCrtc) {
 288   scoped_refptr<ui::MockDrmDevice> drm2 = new ui::MockDrmDevice();
 289
 290   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 291   screen_manager_->AddDisplayController(drm2, kPrimaryCrtc, kPrimaryConnector);
 292
 293   screen_manager_->ConfigureDisplayController(
 294       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 295       kDefaultMode);
 296   screen_manager_->ConfigureDisplayController(
 297       drm2, kPrimaryCrtc, kPrimaryConnector, GetSecondaryBounds().origin(),
 298       kDefaultMode);
 299
 300   ui::HardwareDisplayController* controller1 =
 301       screen_manager_->GetDisplayController(GetPrimaryBounds());
 302   ui::HardwareDisplayController* controller2 =
 303       screen_manager_->GetDisplayController(GetSecondaryBounds());
 304
 305   EXPECT_NE(controller1, controller2);
 306   EXPECT_EQ(drm_, controller1->crtc_controllers()[0]->drm());
 307   EXPECT_EQ(drm2, controller2->crtc_controllers()[0]->drm());
 308 }
 309
 310 TEST_F(ScreenManagerTest, CheckControllerToWindowMappingWithSameBounds) {
 311   ui::DrmDeviceManager device_manager(drm_);
 312   scoped_ptr<ui::DrmWindow> window(
 313       new ui::DrmWindow(1, &device_manager, screen_manager_.get()));
 314   window->Initialize();
 315   window->OnBoundsChanged(GetPrimaryBounds());
 316   screen_manager_->AddWindow(1, window.Pass());
 317
 318   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 319   screen_manager_->ConfigureDisplayController(
 320       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 321       kDefaultMode);
 322
 323   EXPECT_TRUE(screen_manager_->GetWindow(1)->GetController());
 324
 325   window = screen_manager_->RemoveWindow(1);
 326   window->Shutdown();
 327 }
 328
 329 TEST_F(ScreenManagerTest, CheckControllerToWindowMappingWithDifferentBounds) {
 330   ui::DrmDeviceManager device_manager(drm_);
 331   scoped_ptr<ui::DrmWindow> window(
 332       new ui::DrmWindow(1, &device_manager, screen_manager_.get()));
 333   window->Initialize();
 334   gfx::Rect new_bounds = GetPrimaryBounds();
 335   new_bounds.Inset(0, 0, 1, 1);
 336   window->OnBoundsChanged(new_bounds);
 337   screen_manager_->AddWindow(1, window.Pass());
 338
 339   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 340   screen_manager_->ConfigureDisplayController(
 341       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 342       kDefaultMode);
 343
 344   EXPECT_FALSE(screen_manager_->GetWindow(1)->GetController());
 345
 346   window = screen_manager_->RemoveWindow(1);
 347   window->Shutdown();
 348 }
 349
 350 TEST_F(ScreenManagerTest,
 351        CheckControllerToWindowMappingWithOverlappingWindows) {
 352   ui::DrmDeviceManager device_manager(drm_);
 353   const size_t kWindowCount = 2;
 354   for (size_t i = 1; i < kWindowCount + 1; ++i) {
 355     scoped_ptr<ui::DrmWindow> window(
 356         new ui::DrmWindow(1, &device_manager, screen_manager_.get()));
 357     window->Initialize();
 358     window->OnBoundsChanged(GetPrimaryBounds());
 359     screen_manager_->AddWindow(i, window.Pass());
 360   }
 361
 362   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
 363   screen_manager_->ConfigureDisplayController(
 364       drm_, kPrimaryCrtc, kPrimaryConnector, GetPrimaryBounds().origin(),
 365       kDefaultMode);
 366
 367   bool window1_has_controller = screen_manager_->GetWindow(1)->GetController();
 368   bool window2_has_controller = screen_manager_->GetWindow(2)->GetController();
 369   // Only one of the windows can have a controller.
 370   EXPECT_TRUE(window1_has_controller ^ window2_has_controller);
 371
 372   for (size_t i = 1; i < kWindowCount + 1; ++i) {
 373     scoped_ptr<ui::DrmWindow> window = screen_manager_->RemoveWindow(i);
 374     window->Shutdown();
 375   }
 376 }