Atomic: Don’t keep track of Cursor planes

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/ozone/platform/drm/gpu/hardware_display_plane_atomic.h"
 
 #include <drm.h>
 #include <drm/drm_fourcc.h>
 #include <errno.h>
 #include <gbm.h>
 #include <xf86drm.h>
 
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 
 namespace ui {
 namespace {
 
+const char* kTypePropName = "type";
 const char* kCrtcPropName = "CRTC_ID";
 const char* kFbPropName = "FB_ID";
 const char* kCrtcXPropName = "CRTC_X";
 const char* kCrtcYPropName = "CRTC_Y";
 const char* kCrtcWPropName = "CRTC_W";
 const char* kCrtcHPropName = "CRTC_H";
 const char* kSrcXPropName = "SRC_X";
 const char* kSrcYPropName = "SRC_Y";
 const char* kSrcWPropName = "SRC_W";
 const char* kSrcHPropName = "SRC_H";
 
+HardwareDisplayPlane::Type GetPlaneType(int value) {
+  switch (value) {
+    case DRM_PLANE_TYPE_CURSOR:
+      return HardwareDisplayPlane::kCursor;
+    case DRM_PLANE_TYPE_PRIMARY:
+      return HardwareDisplayPlane::kPrimary;
+    case DRM_PLANE_TYPE_OVERLAY:
+      return HardwareDisplayPlane::kOverlay;
+    default:
+      NOTREACHED();
+      return HardwareDisplayPlane::kDummy;
+  }
+}
+
 }  // namespace
 
 HardwareDisplayPlaneAtomic::Property::Property() {
 }
 
 bool HardwareDisplayPlaneAtomic::Property::Initialize(
     DrmDevice* drm,
     const char* name,
     const ScopedDrmObjectPropertyPtr& plane_props) {
   for (uint32_t i = 0; i < plane_props->count_props; i++) {
@@ skipping 45 matching lines @@
                             src_rect.height());
   if (plane_set_error) {
     PLOG(ERROR) << "Failed to set plane data";
     return false;
   }
   return true;
 }
 
 bool HardwareDisplayPlaneAtomic::Initialize(
     DrmDevice* drm,
-    const std::vector<uint32_t>& formats) {
+    const std::vector<uint32_t>& formats,
+    bool is_dummy) {
+  if (is_dummy) {
+    type_ = kDummy;
+    supported_formats_.push_back(DRM_FORMAT_XRGB8888);
+    return true;
+  }
+
   ScopedDrmObjectPropertyPtr plane_props(drmModeObjectGetProperties(
       drm->get_fd(), plane_id_, DRM_MODE_OBJECT_PLANE));
 
   if (!plane_props) {
     PLOG(ERROR) << "Unable to get plane properties.";
     return false;
   }
 
   bool props_init = crtc_prop_.Initialize(drm, kCrtcPropName, plane_props) &&
                     fb_prop_.Initialize(drm, kFbPropName, plane_props) &&
                     crtc_x_prop_.Initialize(drm, kCrtcXPropName, plane_props) &&
                     crtc_y_prop_.Initialize(drm, kCrtcYPropName, plane_props) &&
                     crtc_w_prop_.Initialize(drm, kCrtcWPropName, plane_props) &&
                     crtc_h_prop_.Initialize(drm, kCrtcHPropName, plane_props) &&
                     src_x_prop_.Initialize(drm, kSrcXPropName, plane_props) &&
                     src_y_prop_.Initialize(drm, kSrcYPropName, plane_props) &&
                     src_w_prop_.Initialize(drm, kSrcWPropName, plane_props) &&
                     src_h_prop_.Initialize(drm, kSrcHPropName, plane_props);
 
   if (!props_init) {
     LOG(ERROR) << "Unable to get plane properties.";
     return false;
   }
 
   supported_formats_ = formats;
-  if (is_dummy())
-    supported_formats_.push_back(DRM_FORMAT_XRGB8888);
+
+  for (uint32_t i = 0; i < plane_props->count_props; i++) {
+    ScopedDrmPropertyPtr property(
+        drmModeGetProperty(drm->get_fd(), plane_props->props[i]));
+    if (property && !strcmp(property->name, kTypePropName)) {
+      type_ = GetPlaneType(plane_props->prop_values[i]);
+    }
+  }
 
   return true;
 }
 
 bool HardwareDisplayPlaneAtomic::IsSupportedFormat(uint32_t format) const {
   uint32_t format_type = 0;
   switch (format) {
     case GBM_BO_FORMAT_ARGB8888: {
       // We create a FB of 24 bit color depth.
       format_type = DRM_FORMAT_XRGB8888;
@@ skipping 10 matching lines @@
 
   for (auto& element : supported_formats_) {
     if (element == format_type)
       return true;
   }
 
   return false;
 }
 
 }  // namespace ui