Atomic: Don’t keep track of Cursor planes

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

 // Copyright 2014 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_manager.h"
 
 #include <set>
 
 #include "base/logging.h"
 #include "ui/gfx/geometry/rect.h"
@@ skipping 83 matching lines @@
 
     uint32_t formats_size = drm_plane->count_formats;
     plane_ids.insert(drm_plane->plane_id);
     scoped_ptr<HardwareDisplayPlane> plane(
         CreatePlane(drm_plane->plane_id, drm_plane->possible_crtcs));
 
     std::vector<uint32_t> supported_formats(formats_size);
     for (uint32_t j = 0; j < formats_size; j++)
       supported_formats.push_back(drm_plane->formats[j]);
 
-    if (plane->Initialize(drm, supported_formats)) {
-      planes_.push_back(plane.Pass());
+    if (plane->Initialize(drm, supported_formats, false)) {
+      // CRTC controllers always assume they have a cursor plane and the cursor
+      // plane is updated via cursor specific DRM API. Hence, we dont keep
+      // track of Cursor plane here to avoid re-using it for any other purpose.
+      if (plane->type() != HardwareDisplayPlane::kCursor)
+        planes_.push_back(plane.Pass());
     }
   }
 
   // crbug.com/464085: if driver reports no primary planes for a crtc, create a
   // dummy plane for which we can assign exactly one overlay.
   // TODO(dnicoara): refactor this to simplify AssignOverlayPlanes and move
   // this workaround into HardwareDisplayPlaneLegacy.
   if (!has_universal_planes) {
     for (int i = 0; i < resources->count_crtcs; ++i) {
       if (plane_ids.find(resources->crtcs[i] - 1) == plane_ids.end()) {
         scoped_ptr<HardwareDisplayPlane> dummy_plane(
             CreatePlane(resources->crtcs[i] - 1, (1 << i)));
-        dummy_plane->set_is_dummy(true);
-        if (dummy_plane->Initialize(drm, std::vector<uint32_t>())) {
+        if (dummy_plane->Initialize(drm, std::vector<uint32_t>(), true)) {
           planes_.push_back(dummy_plane.Pass());
         }
       }
     }
   }
 
   std::sort(planes_.begin(), planes_.end(),
             [](HardwareDisplayPlane* l, HardwareDisplayPlane* r) {
               return l->plane_id() < r->plane_id();
             });
@@ skipping 50 matching lines @@
   size_t plane_idx = 0;
   for (const auto& plane : overlay_list) {
     HardwareDisplayPlane* hw_plane =
         FindNextUnusedPlane(&plane_idx, crtc_index, plane.buffer->GetFormat());
     if (!hw_plane) {
       LOG(ERROR) << "Failed to find a free plane for crtc " << crtc_id;
       return false;
     }
 
     gfx::Rect fixed_point_rect;
-    if (!hw_plane->is_dummy()) {
+    if (hw_plane->type() != HardwareDisplayPlane::kDummy) {
       const gfx::Size& size = plane.buffer->GetSize();
       gfx::RectF crop_rect = plane.crop_rect;
       crop_rect.Scale(size.width(), size.height());
 
       // This returns a number in 16.16 fixed point, required by the DRM overlay
       // APIs.
       auto to_fixed_point =
           [](double v) -> uint32_t { return v * kFixedPointScaleValue; };
       fixed_point_rect = gfx::Rect(to_fixed_point(crop_rect.x()),
                                    to_fixed_point(crop_rect.y()),
                                    to_fixed_point(crop_rect.width()),
                                    to_fixed_point(crop_rect.height()));
     }
 
     plane_list->plane_list.push_back(hw_plane);
     hw_plane->set_owning_crtc(crtc_id);
     if (SetPlaneData(plane_list, hw_plane, plane, crtc_id, fixed_point_rect,
                      crtc)) {
       hw_plane->set_in_use(true);
     } else {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace ui