Ozone: Use connectors props in ozone tests

BUG=987274
TEST=DrmOverlayValidatorTest, HardwareDisplayControllerTest,
HardwareDisplayManagerTest

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

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

@@ -40,8 +40,8 @@ constexpr uint32_t kConnectorIdBase = 100;
 constexpr uint32_t kPlaneIdBase = 200;
 constexpr uint32_t kInFormatsBlobPropIdBase = 400;
 
-constexpr uint32_t kTypePropId = 300;
-constexpr uint32_t kInFormatsPropId = 301;
+constexpr uint32_t kTypePropId = 3010;
+constexpr uint32_t kInFormatsPropId = 3011;
 
 }  // namespace
 
@@ -166,19 +166,36 @@ void DrmOverlayValidatorTest::InitializeDrmState(
     const std::vector<CrtcState>& crtc_states) {
   std::vector<ui::MockDrmDevice::CrtcProperties> crtc_properties(
       crtc_states.size());
+  std::map<uint32_t, std::string> crtc_property_names = {
+      {1000, "ACTIVE"},
+      {1001, "MODE_ID"},
+  };
+
+  std::vector<ui::MockDrmDevice::ConnectorProperties> connector_properties(2);
+  std::map<uint32_t, std::string> connector_property_names = {
+      {2000, "CRTC_ID"},
+  };
+  for (size_t i = 0; i < connector_properties.size(); ++i) {
+    connector_properties[i].id = kConnectorIdBase + i;
+    for (const auto& pair : connector_property_names) {
+      connector_properties[i].properties.push_back(
+          {/* .id = */ pair.first, /* .value = */ 0});
+    }
+  }
+
   std::vector<ui::MockDrmDevice::PlaneProperties> plane_properties;
-  std::map<uint32_t, std::string> property_names = {
+  std::map<uint32_t, std::string> plane_property_names = {
       // Add all required properties.
-      {1000, "CRTC_ID"},
-      {1001, "CRTC_X"},
-      {1002, "CRTC_Y"},
-      {1003, "CRTC_W"},
-      {1004, "CRTC_H"},
-      {1005, "FB_ID"},
-      {1006, "SRC_X"},
-      {1007, "SRC_Y"},
-      {1008, "SRC_W"},
-      {1009, "SRC_H"},
+      {3000, "CRTC_ID"},
+      {3001, "CRTC_X"},
+      {3002, "CRTC_Y"},
+      {3003, "CRTC_W"},
+      {3004, "CRTC_H"},
+      {3005, "FB_ID"},
+      {3006, "SRC_X"},
+      {3007, "SRC_Y"},
+      {3008, "SRC_W"},
+      {3009, "SRC_H"},
       // Defines some optional properties we use for convenience.
       {kTypePropId, "type"},
       {kInFormatsPropId, "IN_FORMATS"},
@@ -189,6 +206,10 @@ void DrmOverlayValidatorTest::InitializeDrmState(
 
   for (size_t crtc_idx = 0; crtc_idx < crtc_states.size(); ++crtc_idx) {
     crtc_properties[crtc_idx].id = kCrtcIdBase + crtc_idx;
+    for (const auto& pair : crtc_property_names) {
+      crtc_properties[crtc_idx].properties.push_back(
+          {/* .id = */ pair.first, /* .value = */ 0});
+    }
 
     std::vector<ui::MockDrmDevice::PlaneProperties> crtc_plane_properties(
         crtc_states[crtc_idx].planes.size());
@@ -197,7 +218,7 @@ void DrmOverlayValidatorTest::InitializeDrmState(
       crtc_plane_properties[plane_idx].id = plane_id++;
       crtc_plane_properties[plane_idx].crtc_mask = 1 << crtc_idx;
 
-      for (const auto& pair : property_names) {
+      for (const auto& pair : plane_property_names) {
         uint64_t value = 0;
         if (pair.first == kTypePropId) {
           value =
@@ -219,9 +240,12 @@ void DrmOverlayValidatorTest::InitializeDrmState(
                             crtc_plane_properties.end());
   }
 
-  std::vector<ui::MockDrmDevice::ConnectorProperties> connector_properties(1);
-  connector_properties[0].id = kConnectorIdBase;
-
+  std::map<uint32_t, std::string> property_names;
+  property_names.insert(crtc_property_names.begin(), crtc_property_names.end());
+  property_names.insert(connector_property_names.begin(),
+                        connector_property_names.end());
+  property_names.insert(plane_property_names.begin(),
+                        plane_property_names.end());
   drm_->InitializeState(crtc_properties, connector_properties, plane_properties,
                         property_names,
                         /* use_atomic= */ true);

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

@@ -99,6 +99,10 @@ void HardwareDisplayController::Disable() {
   TRACE_EVENT0("drm", "HDC::Disable");
 
   for (const auto& controller : crtc_controllers_)
+    // TODO(crbug.com/1015104): Modeset and Disable operations should go
+    // together. The current split is due to how the legacy/atomic split
+    // evolved. It should be cleaned up under the more generic
+    // HardwareDisplayPlaneManager{Legacy,Atomic} calls.
     controller->Disable();
 
   bool ret = GetDrmDevice()->plane_manager()->DisableOverlayPlanes(

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

@@ -33,8 +33,7 @@ const drmModeModeInfo kDefaultMode = {0, 6, 0, 0, 0, 0, 4,     0,
 constexpr uint32_t kCrtcIdBase = 1;
 constexpr uint32_t kPrimaryCrtc = kCrtcIdBase;
 constexpr uint32_t kSecondaryCrtc = kCrtcIdBase + 1;
-constexpr uint32_t kPrimaryConnector = 10;
-constexpr uint32_t kSecondaryConnector = 11;
+constexpr uint32_t kConnectorIdBase = 10;
 constexpr uint32_t kPlaneOffset = 1000;
 
 const gfx::Size kDefaultModeSize(kDefaultMode.hdisplay, kDefaultMode.vdisplay);
@@ -94,7 +93,7 @@ void HardwareDisplayControllerTest::SetUp() {
 
   controller_ = std::make_unique<ui::HardwareDisplayController>(
       std::make_unique<ui::CrtcController>(drm_.get(), kPrimaryCrtc,
-                                           kPrimaryConnector),
+                                           kConnectorIdBase),
       gfx::Point());
 }
 
@@ -104,24 +103,41 @@ void HardwareDisplayControllerTest::TearDown() {
 }
 
 void HardwareDisplayControllerTest::InitializeDrmDevice(bool use_atomic) {
-  constexpr uint32_t kTypePropId = 300;
-  constexpr uint32_t kInFormatsPropId = 301;
+  constexpr uint32_t kTypePropId = 3010;
+  constexpr uint32_t kInFormatsPropId = 3011;
   constexpr uint32_t kInFormatsBlobPropId = 400;
 
   std::vector<ui::MockDrmDevice::CrtcProperties> crtc_properties(2);
+  std::map<uint32_t, std::string> crtc_property_names = {
+      {1000, "ACTIVE"},
+      {1001, "MODE_ID"},
+  };
+
+  std::vector<ui::MockDrmDevice::ConnectorProperties> connector_properties(2);
+  std::map<uint32_t, std::string> connector_property_names = {
+      {2000, "CRTC_ID"},
+  };
+  for (size_t i = 0; i < connector_properties.size(); ++i) {
+    connector_properties[i].id = kConnectorIdBase + i;
+    for (const auto& pair : connector_property_names) {
+      connector_properties[i].properties.push_back(
+          {/* .id = */ pair.first, /* .value = */ 0});
+    }
+  }
+
   std::vector<ui::MockDrmDevice::PlaneProperties> plane_properties;
-  std::map<uint32_t, std::string> property_names = {
+  std::map<uint32_t, std::string> plane_property_names = {
       // Add all required properties.
-      {200, "CRTC_ID"},
-      {201, "CRTC_X"},
-      {202, "CRTC_Y"},
-      {203, "CRTC_W"},
-      {204, "CRTC_H"},
-      {205, "FB_ID"},
-      {206, "SRC_X"},
-      {207, "SRC_Y"},
-      {208, "SRC_W"},
-      {209, "SRC_H"},
+      {3000, "CRTC_ID"},
+      {3001, "CRTC_X"},
+      {3002, "CRTC_Y"},
+      {3003, "CRTC_W"},
+      {3004, "CRTC_H"},
+      {3005, "FB_ID"},
+      {3006, "SRC_X"},
+      {3007, "SRC_Y"},
+      {3008, "SRC_W"},
+      {3009, "SRC_H"},
       // Add some optional properties we use for convenience.
       {kTypePropId, "type"},
       {kInFormatsPropId, "IN_FORMATS"},
@@ -129,6 +145,10 @@ void HardwareDisplayControllerTest::InitializeDrmDevice(bool use_atomic) {
 
   for (size_t i = 0; i < crtc_properties.size(); ++i) {
     crtc_properties[i].id = kCrtcIdBase + i;
+    for (const auto& pair : crtc_property_names) {
+      crtc_properties[i].properties.push_back(
+          {/* .id = */ pair.first, /* .value = */ 0});
+    }
 
     for (size_t j = 0; j < 2; ++j) {
       const uint32_t offset = plane_properties.size();
@@ -136,7 +156,7 @@ void HardwareDisplayControllerTest::InitializeDrmDevice(bool use_atomic) {
       ui::MockDrmDevice::PlaneProperties plane;
       plane.id = kPlaneOffset + offset;
       plane.crtc_mask = 1 << i;
-      for (const auto& pair : property_names) {
+      for (const auto& pair : plane_property_names) {
         uint32_t value = 0;
         if (pair.first == kTypePropId)
           value = j == 0 ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
@@ -163,10 +183,12 @@ void HardwareDisplayControllerTest::InitializeDrmDevice(bool use_atomic) {
     }
   }
 
-  std::vector<ui::MockDrmDevice::ConnectorProperties> connector_properties(2);
-  connector_properties[0].id = kPrimaryConnector;
-  connector_properties[1].id = kSecondaryConnector;
-
+  std::map<uint32_t, std::string> property_names;
+  property_names.insert(crtc_property_names.begin(), crtc_property_names.end());
+  property_names.insert(connector_property_names.begin(),
+                        connector_property_names.end());
+  property_names.insert(plane_property_names.begin(),
+                        plane_property_names.end());
   drm_->InitializeState(crtc_properties, connector_properties, plane_properties,
                         property_names, use_atomic);
 }
@@ -379,8 +401,9 @@ TEST_F(HardwareDisplayControllerTest, AcceptUnderlays) {
 }
 
 TEST_F(HardwareDisplayControllerTest, PageflipMirroredControllers) {
-  controller_->AddCrtc(std::unique_ptr<ui::CrtcController>(
-      new ui::CrtcController(drm_.get(), kSecondaryCrtc, kSecondaryConnector)));
+  controller_->AddCrtc(
+      std::unique_ptr<ui::CrtcController>(new ui::CrtcController(
+          drm_.get(), kSecondaryCrtc, kConnectorIdBase + 1)));
 
   ui::DrmOverlayPlane plane1(CreateBuffer(), nullptr);
   EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
@@ -404,8 +427,9 @@ TEST_F(HardwareDisplayControllerTest, PageflipMirroredControllers) {
 }
 
 TEST_F(HardwareDisplayControllerTest, PlaneStateAfterRemoveCrtc) {
-  controller_->AddCrtc(std::unique_ptr<ui::CrtcController>(
-      new ui::CrtcController(drm_.get(), kSecondaryCrtc, kSecondaryConnector)));
+  controller_->AddCrtc(
+      std::unique_ptr<ui::CrtcController>(new ui::CrtcController(
+          drm_.get(), kSecondaryCrtc, kConnectorIdBase + 1)));
 
   ui::DrmOverlayPlane plane1(CreateBuffer(), nullptr);
   EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
@@ -476,8 +500,9 @@ TEST_F(HardwareDisplayControllerTest, PlaneStateAfterDestroyingCrtc) {
 }
 
 TEST_F(HardwareDisplayControllerTest, PlaneStateAfterAddCrtc) {
-  controller_->AddCrtc(std::unique_ptr<ui::CrtcController>(
-      new ui::CrtcController(drm_.get(), kSecondaryCrtc, kSecondaryConnector)));
+  controller_->AddCrtc(
+      std::unique_ptr<ui::CrtcController>(new ui::CrtcController(
+          drm_.get(), kSecondaryCrtc, kConnectorIdBase + 1)));
 
   ui::DrmOverlayPlane plane1(CreateBuffer(), nullptr);
   EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
@@ -569,8 +594,9 @@ TEST_F(HardwareDisplayControllerTest, AddCrtcMidPageFlip) {
   planes.push_back(plane1.Clone());
   SchedulePageFlip(std::move(planes));
 
-  controller_->AddCrtc(std::unique_ptr<ui::CrtcController>(
-      new ui::CrtcController(drm_.get(), kSecondaryCrtc, kSecondaryConnector)));
+  controller_->AddCrtc(
+      std::unique_ptr<ui::CrtcController>(new ui::CrtcController(
+          drm_.get(), kSecondaryCrtc, kConnectorIdBase + 1)));
 
   drm_->RunCallbacks();
   EXPECT_EQ(gfx::SwapResult::SWAP_ACK, last_swap_result_);

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

@@ -31,17 +31,19 @@
 namespace {
 
 constexpr uint32_t kPlaneOffset = 100;
-constexpr uint32_t kTypePropId = 300;
-constexpr uint32_t kInFormatsPropId = 301;
-constexpr uint32_t kPlaneCtmId = 302;
-constexpr uint32_t kCtmPropId = 303;
-constexpr uint32_t kGammaLutPropId = 304;
-constexpr uint32_t kGammaLutSizePropId = 305;
-constexpr uint32_t kDegammaLutPropId = 306;
-constexpr uint32_t kDegammaLutSizePropId = 307;
-constexpr uint32_t kOutFencePtrPropId = 308;
+constexpr uint32_t kConnectorIdBase = 700;
+
+constexpr uint32_t kTypePropId = 3010;
+constexpr uint32_t kInFormatsPropId = 3011;
+constexpr uint32_t kPlaneCtmId = 3012;
+constexpr uint32_t kBackgroundColorPropId = 1002;
+constexpr uint32_t kCtmPropId = 1003;
+constexpr uint32_t kGammaLutPropId = 1004;
+constexpr uint32_t kGammaLutSizePropId = 1005;
+constexpr uint32_t kDegammaLutPropId = 1006;
+constexpr uint32_t kDegammaLutSizePropId = 1007;
+constexpr uint32_t kOutFencePtrPropId = 1008;
 constexpr uint32_t kInFormatsBlobPropId = 400;
-constexpr uint32_t kBackgroundColorPropId = 401;
 
 const gfx::Size kDefaultBufferSize(2, 2);
 // Create a basic mode for a 6x4 screen.
@@ -110,35 +112,60 @@ void HardwareDisplayPlaneManagerTest::SetUp() {
 void HardwareDisplayPlaneManagerTest::InitializeDrmState(
     size_t crtc_count,
     size_t planes_per_crtc) {
-  property_names_ = {
+  std::map<uint32_t, std::string> crtc_property_names = {
+      {1000, "ACTIVE"},
+      {1001, "MODE_ID"},
+  };
+
+  std::vector<ui::MockDrmDevice::ConnectorProperties> connector_properties(1);
+  std::map<uint32_t, std::string> connector_property_names = {
+      {2000, "CRTC_ID"},
+  };
+  for (size_t i = 0; i < connector_properties.size(); ++i) {
+    connector_properties[i].id = kConnectorIdBase + i;
+    for (const auto& pair : connector_property_names) {
+      connector_properties[i].properties.push_back(
+          {/* .id = */ pair.first, /* .value = */ 0});
+    }
+  }
+  connector_properties_ = connector_properties;
+
+  std::vector<ui::MockDrmDevice::PlaneProperties> plane_properties(
+      planes_per_crtc * crtc_count);
+  std::map<uint32_t, std::string> plane_property_names = {
       // Add all required properties.
-      {200, "CRTC_ID"},
-      {201, "CRTC_X"},
-      {202, "CRTC_Y"},
-      {203, "CRTC_W"},
-      {204, "CRTC_H"},
-      {205, "FB_ID"},
-      {206, "SRC_X"},
-      {207, "SRC_Y"},
-      {208, "SRC_W"},
-      {209, "SRC_H"},
+      {3000, "CRTC_ID"},
+      {3001, "CRTC_X"},
+      {3002, "CRTC_Y"},
+      {3003, "CRTC_W"},
+      {3004, "CRTC_H"},
+      {3005, "FB_ID"},
+      {3006, "SRC_X"},
+      {3007, "SRC_Y"},
+      {3008, "SRC_W"},
+      {3009, "SRC_H"},
       // Defines some optional properties we use for convenience.
       {kTypePropId, "type"},
       {kInFormatsPropId, "IN_FORMATS"},
   };
+
   // Always add an additional cursor plane.
   ++planes_per_crtc;
   for (size_t i = 0; i < crtc_count; ++i) {
     ui::MockDrmDevice::CrtcProperties crtc_prop;
     // Start ID at 1 cause 0 is an invalid ID.
     crtc_prop.id = i + 1;
+    for (const auto& pair : crtc_property_names) {
+      crtc_prop.properties.push_back(
+          {/* .id = */ pair.first, /* .value = */ 0});
+    }
     crtc_properties_.emplace_back(std::move(crtc_prop));
 
     for (size_t j = 0; j < planes_per_crtc; ++j) {
       ui::MockDrmDevice::PlaneProperties plane_prop;
       plane_prop.id = kPlaneOffset + i * planes_per_crtc + j;
       plane_prop.crtc_mask = 1 << i;
-      for (const auto& pair : property_names_) {
+      for (const auto& pair : plane_property_names) {
         uint32_t value = 0;
         if (pair.first == kTypePropId) {
           if (j == 0)
@@ -158,23 +185,26 @@ void HardwareDisplayPlaneManagerTest::InitializeDrmState(
     }
   }
 
+  property_names_.insert(crtc_property_names.begin(),
+                         crtc_property_names.end());
+  property_names_.insert(connector_property_names.begin(),
+                         connector_property_names.end());
+  property_names_.insert(plane_property_names.begin(),
+                         plane_property_names.end());
+
   // Separately add optional properties that will be used in some tests, but the
   // tests will append the property to the planes on a case-by-case basis.
   //
   // Plane properties:
   property_names_.insert({kPlaneCtmId, "PLANE_CTM"});
   // CRTC properties:
+  property_names_.insert({kBackgroundColorPropId, "BACKGROUND_COLOR"});
   property_names_.insert({kCtmPropId, "CTM"});
   property_names_.insert({kGammaLutPropId, "GAMMA_LUT"});
   property_names_.insert({kGammaLutSizePropId, "GAMMA_LUT_SIZE"});
   property_names_.insert({kDegammaLutPropId, "DEGAMMA_LUT"});
   property_names_.insert({kDegammaLutSizePropId, "DEGAMMA_LUT_SIZE"});
   property_names_.insert({kOutFencePtrPropId, "OUT_FENCE_PTR"});
-  property_names_.insert({kBackgroundColorPropId, "BACKGROUND_COLOR"});
-
-  ui::MockDrmDevice::ConnectorProperties connector_prop;
-  connector_prop.id = 1000;
-  connector_properties_.emplace_back(std::move(connector_prop));
 }
 
 void HardwareDisplayPlaneManagerTest::PerformPageFlip(

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

@@ -146,6 +146,7 @@ bool MockDrmDevice::InitializeStateWithResult(
     const std::map<uint32_t, std::string>& property_names,
     bool use_atomic) {
   crtc_properties_ = crtc_properties;
+  connector_properties_ = connector_properties;
   plane_properties_ = plane_properties;
   property_names_ = property_names;
   if (use_atomic) {
@@ -167,6 +168,12 @@ ScopedDrmResourcesPtr MockDrmDevice::GetResources() {
   for (size_t i = 0; i < crtc_properties_.size(); ++i)
     resources->crtcs[i] = crtc_properties_[i].id;
 
+  resources->count_connectors = connector_properties_.size();
+  resources->connectors = static_cast<uint32_t*>(
+      drmMalloc(sizeof(uint32_t) * resources->count_connectors));
+  for (size_t i = 0; i < connector_properties_.size(); ++i)
+    resources->connectors[i] = connector_properties_[i].id;
+
   return resources;
 }
 
@@ -192,6 +199,11 @@ ScopedDrmObjectPropertyPtr MockDrmDevice::GetObjectProperties(
     CrtcProperties* properties = FindObjectById(object_id, crtc_properties_);
     if (properties)
       return CreatePropertyObject(properties->properties);
+  } else if (object_type == DRM_MODE_OBJECT_CONNECTOR) {
+    ConnectorProperties* properties =
+        FindObjectById(object_id, connector_properties_);
+    if (properties)
+      return CreatePropertyObject(properties->properties);
   }
 
   return nullptr;
@@ -485,6 +497,13 @@ bool MockDrmDevice::UpdateProperty(uint32_t object_id,
   if (crtc_properties)
     return UpdateProperty(property_id, value, &crtc_properties->properties);
 
+  ConnectorProperties* connector_properties =
+      FindObjectById(object_id, connector_properties_);
+  if (connector_properties) {
+    return UpdateProperty(property_id, value,
+                          &connector_properties->properties);
+  }
+
   return false;
 }