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";
@@ skipping 56 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_ = Dummy;
+    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)) {
+      int value = plane_props->prop_values[i];
+      switch (value) {

[dnicoara, 2015/08/20 14:22:46]

Could you please split this in a helper function? Then just have something like
"type_ = GetPlaneType(plane_props->prop_values[i]);"

[kalyank, 2015/08/20 16:36:18]

Done.

+        case DRM_PLANE_TYPE_CURSOR:
+          type_ = Cursor;
+          break;
+        case DRM_PLANE_TYPE_PRIMARY:
+          type_ = Primary;
+          break;
+        case DRM_PLANE_TYPE_OVERLAY:
+          type_ = Overlay;
+          break;
+        default:
+          break;
+      }
+      break;
+    }
+  }
 
   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