Atomic: Don’t keep track of Cursor planes

ui/ozone/platform/drm/gpu/crtc_controller.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/crtc_controller.h"
 
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/page_flip_request.h"
 #include "ui/ozone/platform/drm/gpu/scanout_buffer.h"
 
 namespace ui {
 
 CrtcController::CrtcController(const scoped_refptr<DrmDevice>& drm,
                                uint32_t crtc,
                                uint32_t connector)
-    : drm_(drm),
-      crtc_(crtc),
-      connector_(connector) {}
+    : drm_(drm), cursor_plane_(nullptr), crtc_(crtc), connector_(connector) {}
 
 CrtcController::~CrtcController() {
   if (!is_disabled_) {
     const ScopedVector<HardwareDisplayPlane>& all_planes =
         drm_->plane_manager()->planes();
     for (auto* plane : all_planes) {
       if (plane->owning_crtc() == crtc_) {
         plane->set_owning_crtc(0);
         plane->set_in_use(false);
       }
@@ skipping 108 matching lines @@
 }
 
 bool CrtcController::MoveCursor(const gfx::Point& location) {
   DCHECK(!is_disabled_);
   return drm_->MoveCursor(crtc_, location);
 }
 
 bool CrtcController::ResetCursor() {
   uint32_t handle = 0;
   gfx::Size size;
-
+#if defined(USE_DRM_ATOMIC)
+  if (!cursor_plane_) {

[dnicoara, 2015/08/21 21:38:38]

I was thinking that HardwareDisplayPlaneManager should mark them as always in
use. That would simplify the remainder of the logic since the CRTC controllers
always assume they have a cursor plane and the cursor plane is updated via a
cursor specific DRM API.

[kalyank, 2015/08/21 22:05:58]

K, I have changed so that we dont even keep track of Cursor planes in
HardwareDisplayManager (As we dont do anything with them later). 

+    const ScopedVector<HardwareDisplayPlane>& all_planes =
+        drm_->plane_manager()->planes();
+    for (auto* plane : all_planes) {
+      if (plane->CanUseForCrtc(crtc_) &&
+          (plane->type() == HardwareDisplayPlane::kCursor)) {
+        cursor_plane_ = plane;
+      }
+    }
+  }
+#endif
   if (cursor_buffer_) {
     handle = cursor_buffer_->GetHandle();
     size = cursor_buffer_->GetSize();
   }
 
   bool status = drm_->SetCursor(crtc_, handle, size);
+  if (cursor_plane_) {
+    if (status && handle) {
+      cursor_plane_->set_owning_crtc(crtc_);
+      cursor_plane_->set_in_use(true);
+    } else {
+      cursor_plane_->set_owning_crtc(0);
+      cursor_plane_->set_in_use(false);
+      cursor_plane_ = nullptr;
+    }
+  }
+
   if (!status) {
     PLOG(ERROR) << "drmModeSetCursor: device " << drm_->device_path().value()
                 << " crtc " << crtc_ << " handle " << handle << " size "
                 << size.ToString();
   }
 
   return status;
 }
 
 void CrtcController::SignalPageFlipRequest() {
   if (page_flip_request_.get()) {
     // If another frame is queued up and available immediately, calling Signal()
     // may result in a call to SchedulePageFlip(), which will override
     // page_flip_request_ and possibly release the ref. Stash previous request
     // locally to  avoid deleting the object we are making a call on.
     scoped_refptr<PageFlipRequest> last_request;
     last_request.swap(page_flip_request_);
     last_request->Signal(gfx::SwapResult::SWAP_ACK);
   }
 }
 
 }  // namespace ui