Implement Unittests for Test Modeset and Commit Modeset.

1. Extend Mock DRM Device to get a count of test | modeset and modeset
commit flags.
2. Test of the expected number of test modeset and commit modeset on
displays enable/disable.

BUG=b/172622447
TEST=ScreenManagerTest.{CheckWithNoControllers,
CheckWithValidController, CheckForSecondValidController,
CheckControllerAfterDisabled, CheckMultipleControllersAfterBeingRemoved,
CheckMultipleControllersAfterBeingDisabled}

Change-Id: Iac4b1fae4119677dad19b904ff6b1923d18b6a5a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2526944Reviewed-by: Daniel Nicoara <dnicoara@chromium.org>
Commit-Queue: Mark Yacoub <markyacoub@google.com>
Cr-Commit-Position: refs/heads/master@{#825405}

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

@@ -36,6 +36,11 @@ namespace ui {
 
 namespace {
 
+constexpr uint32_t kTestModesetFlags =
+    DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET;
+
+constexpr uint32_t kCommitModesetFlags = DRM_MODE_ATOMIC_ALLOW_MODESET;
+
 template <class Object>
 Object* DrmAllocator() {
   return static_cast<Object*>(drmMalloc(sizeof(Object)));
@@ -327,7 +332,7 @@ ScopedDrmPropertyBlob MockDrmDevice::CreatePropertyBlob(const void* blob,
                                                         size_t size) {
   uint32_t id = ++property_id_generator_;
   allocated_property_blobs_.insert(id);
-  return ScopedDrmPropertyBlob(new DrmPropertyBlobMetadata(this, id));
+  return std::make_unique<DrmPropertyBlobMetadata>(this, id);
 }
 
 void MockDrmDevice::DestroyPropertyBlob(uint32_t id) {
@@ -427,6 +432,11 @@ bool MockDrmDevice::CommitProperties(
     uint32_t flags,
     uint32_t crtc_count,
     scoped_refptr<PageFlipRequest> page_flip_request) {
+  if (flags == kTestModesetFlags)
+    ++test_modeset_count_;
+  else if (flags == kCommitModesetFlags)
+    ++commit_modeset_count_;
+
   commit_count_++;
   if (!commit_expectation_)
     return false;

ui/ozone/platform/drm/gpu/mock_drm_device.h

@@ -71,6 +71,8 @@ class MockDrmDevice : public DrmDevice {
   }
   int get_page_flip_call_count() const { return page_flip_call_count_; }
   int get_overlay_clear_call_count() const { return overlay_clear_call_count_; }
+  int get_test_modeset_count() const { return test_modeset_count_; }
+  int get_commit_modeset_count() const { return commit_modeset_count_; }
   int get_commit_count() const { return commit_count_; }
   int get_set_object_property_count() const {
     return set_object_property_count_;
@@ -203,6 +205,8 @@ class MockDrmDevice : public DrmDevice {
   int page_flip_call_count_;
   int overlay_clear_call_count_;
   int allocate_buffer_count_;
+  int test_modeset_count_ = 0;
+  int commit_modeset_count_ = 0;
   int commit_count_ = 0;
   int set_object_property_count_ = 0;
   int set_gamma_ramp_count_ = 0;

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

@@ -225,6 +225,9 @@ class ScreenManagerTest : public testing::Test {
 
 TEST_F(ScreenManagerTest, CheckWithNoControllers) {
   EXPECT_FALSE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
+  EXPECT_EQ(drm_->get_test_modeset_count(), 0);
+  EXPECT_EQ(drm_->get_commit_modeset_count(), 0);
+  EXPECT_EQ(drm_->get_commit_count(), 0);
 }
 
 TEST_F(ScreenManagerTest, CheckWithValidController) {
@@ -238,6 +241,8 @@ TEST_F(ScreenManagerTest, CheckWithValidController) {
       GetPrimaryBounds().origin(),
       std::make_unique<drmModeModeInfo>(kDefaultMode));
   screen_manager_->ConfigureDisplayControllers(controllers_to_enable);
+  EXPECT_EQ(drm_->get_test_modeset_count(), 1);
+  EXPECT_EQ(drm_->get_commit_modeset_count(), 1);
 
   ui::HardwareDisplayController* controller =
       screen_manager_->GetDisplayController(GetPrimaryBounds());
@@ -281,6 +286,9 @@ TEST_F(ScreenManagerTest, CheckForSecondValidController) {
       std::make_unique<drmModeModeInfo>(secondary_mode));
   screen_manager_->ConfigureDisplayControllers(controllers_to_enable);
 
+  EXPECT_EQ(drm_->get_test_modeset_count(), 1);
+  EXPECT_EQ(drm_->get_commit_modeset_count(), 2);
+
   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
   EXPECT_TRUE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 }
@@ -300,12 +308,41 @@ TEST_F(ScreenManagerTest, CheckControllerAfterItIsRemoved) {
   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
 
   ScreenManager::CrtcsWithDrmList controllers_to_remove;
-
   controllers_to_remove.emplace_back(kPrimaryCrtc, drm_);
   screen_manager_->RemoveDisplayControllers(controllers_to_remove);
   EXPECT_FALSE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
 }
 
+TEST_F(ScreenManagerTest, CheckControllerAfterDisabled) {
+  InitializeDrmStateWithDefault(drm_.get());
+  screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
+
+  // Enable
+  {
+    ScreenManager::ControllerConfigsList controllers_to_enable;
+    controllers_to_enable.emplace_back(
+        kPrimaryDisplayId, drm_, kPrimaryCrtc, kPrimaryConnector,
+        GetPrimaryBounds().origin(),
+        std::make_unique<drmModeModeInfo>(kDefaultMode));
+    screen_manager_->ConfigureDisplayControllers(controllers_to_enable);
+  }
+
+  int test_modeset_count_before_disable = drm_->get_test_modeset_count();
+  int commit_modeset_count_before_disable = drm_->get_commit_modeset_count();
+  // Disable
+  ScreenManager::ControllerConfigsList controllers_to_enable;
+  controllers_to_enable.emplace_back(kPrimaryDisplayId, drm_, kPrimaryCrtc,
+                                     kPrimaryConnector, gfx::Point(), nullptr);
+  screen_manager_->ConfigureDisplayControllers(controllers_to_enable);
+
+  EXPECT_EQ(drm_->get_test_modeset_count(),
+            test_modeset_count_before_disable + 1);
+  EXPECT_EQ(drm_->get_commit_modeset_count(),
+            commit_modeset_count_before_disable + 1);
+
+  EXPECT_FALSE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
+}
+
 TEST_F(ScreenManagerTest, CheckMultipleControllersAfterBeingRemoved) {
   InitializeDrmStateWithDefault(drm_.get());
 
@@ -324,11 +361,54 @@ TEST_F(ScreenManagerTest, CheckMultipleControllersAfterBeingRemoved) {
       std::make_unique<drmModeModeInfo>(kDefaultMode));
   screen_manager_->ConfigureDisplayControllers(controllers_to_enable);
 
+  int modeset_count_after_enable = drm_->get_commit_modeset_count();
   ScreenManager::CrtcsWithDrmList controllers_to_remove;
   controllers_to_remove.emplace_back(kPrimaryCrtc, drm_);
   controllers_to_remove.emplace_back(kSecondaryCrtc, drm_);
   screen_manager_->RemoveDisplayControllers(controllers_to_remove);
 
+  // Removed displays are disabled in only 1 modeset commit.
+  EXPECT_EQ(drm_->get_commit_modeset_count(), modeset_count_after_enable + 1);
+
+  EXPECT_FALSE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
+  EXPECT_FALSE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
+}
+
+TEST_F(ScreenManagerTest, CheckMultipleControllersAfterBeingDisabled) {
+  InitializeDrmStateWithDefault(drm_.get());
+  screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
+  screen_manager_->AddDisplayController(drm_, kSecondaryCrtc,
+                                        kSecondaryConnector);
+  // Enable
+  {
+    ScreenManager::ControllerConfigsList controllers_to_enable;
+    controllers_to_enable.emplace_back(
+        kPrimaryDisplayId, drm_, kPrimaryCrtc, kPrimaryConnector,
+        GetPrimaryBounds().origin(),
+        std::make_unique<drmModeModeInfo>(kDefaultMode));
+    controllers_to_enable.emplace_back(
+        kSecondaryDisplayId, drm_, kSecondaryCrtc, kSecondaryConnector,
+        GetSecondaryBounds().origin(),
+        std::make_unique<drmModeModeInfo>(kDefaultMode));
+    screen_manager_->ConfigureDisplayControllers(controllers_to_enable);
+  }
+
+  int test_modeset_count_before_disable = drm_->get_test_modeset_count();
+  int commit_modeset_count_before_disable = drm_->get_commit_modeset_count();
+  // Disable
+  ScreenManager::ControllerConfigsList controllers_to_enable;
+  controllers_to_enable.emplace_back(kPrimaryDisplayId, drm_, kPrimaryCrtc,
+                                     kPrimaryConnector, gfx::Point(), nullptr);
+  controllers_to_enable.emplace_back(kSecondaryDisplayId, drm_, kSecondaryCrtc,
+                                     kSecondaryConnector, gfx::Point(),
+                                     nullptr);
+  screen_manager_->ConfigureDisplayControllers(controllers_to_enable);
+
+  EXPECT_EQ(drm_->get_test_modeset_count(),
+            test_modeset_count_before_disable + 1);
+  EXPECT_EQ(drm_->get_commit_modeset_count(),
+            commit_modeset_count_before_disable + 2);
+
   EXPECT_FALSE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
   EXPECT_FALSE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 }