[Ozone-DRM] Use CRTC's mode when configuring it for mirror mode

ui/ozone/platform/drm/gpu/screen_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/screen_manager.h"
 
 #include <xf86drmMode.h>
 
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/point.h"
@@ skipping 47 matching lines @@
     return;
   }
 
   skia::RefPtr<SkImage> image = saved_buffer.image();
   SkPaint paint;
   // Copy the source buffer. Do not perform any blending.
   paint.setXfermodeMode(SkXfermode::kSrc_Mode);
   modeset_buffer.canvas()->drawImage(image.get(), 0, 0, &paint);
 }
 
+CrtcController* GetCrtcController(HardwareDisplayController* controller,
+                                  const scoped_refptr<DrmDevice>& drm,
+                                  uint32_t crtc) {
+  for (CrtcController* crtc_controller : controller->crtc_controllers()) {
+    if (crtc_controller->crtc() == crtc)
+      return crtc_controller;
+  }
+
+  NOTREACHED();
+  return nullptr;
+}
+
 }  // namespace
 
 ScreenManager::ScreenManager(ScanoutBufferGenerator* buffer_generator)
     : buffer_generator_(buffer_generator) {
 }
 
 ScreenManager::~ScreenManager() {
   DCHECK(window_map_.empty());
 }
 
@@ skipping 48 matching lines @@
     uint32_t connector,
     const gfx::Point& origin,
     const drmModeModeInfo& mode) {
   gfx::Rect modeset_bounds(origin.x(), origin.y(), mode.hdisplay,
                            mode.vdisplay);
   HardwareDisplayControllers::iterator it = FindDisplayController(drm, crtc);
   DCHECK(controllers_.end() != it) << "Display controller (crtc=" << crtc
                                    << ") doesn't exist.";
 
   HardwareDisplayController* controller = *it;
+  CrtcController* crtc_controller = GetCrtcController(controller, drm, crtc);
   // If nothing changed just enable the controller. Note, we perform an exact
   // comparison on the mode since the refresh rate may have changed.
-  if (SameMode(mode, controller->get_mode()) &&
+  if (SameMode(mode, crtc_controller->mode()) &&
       origin == controller->origin()) {
     if (controller->IsDisabled()) {
       HardwareDisplayControllers::iterator mirror =
           FindActiveDisplayControllerByLocation(modeset_bounds);
       // If there is an active controller at the same location then start mirror
       // mode.
       if (mirror != controllers_.end())
-        return HandleMirrorMode(it, mirror, drm, crtc, connector);
+        return HandleMirrorMode(it, mirror, drm, crtc, connector, mode);
     }
 
     // Just re-enable the controller to re-use the current state.
-    return EnableController(controller, controller->origin(),
-                            controller->get_mode());
+    return EnableController(controller);
   }
 
   // Either the mode or the location of the display changed, so exit mirror
   // mode and configure the display independently. If the caller still wants
   // mirror mode, subsequent calls configuring the other controllers will
   // restore mirror mode.
   if (controller->IsMirrored()) {
     controller = new HardwareDisplayController(
         controller->RemoveCrtc(drm, crtc), controller->origin());
     controllers_.push_back(controller);
     it = controllers_.end() - 1;
   }
 
   HardwareDisplayControllers::iterator mirror =
       FindActiveDisplayControllerByLocation(modeset_bounds);
   // Handle mirror mode.
   if (mirror != controllers_.end() && it != mirror)
-    return HandleMirrorMode(it, mirror, drm, crtc, connector);
+    return HandleMirrorMode(it, mirror, drm, crtc, connector, mode);
 
-  return EnableController(controller, origin, mode);
+  return ModesetController(controller, origin, mode);
 }
 
 bool ScreenManager::DisableDisplayController(
     const scoped_refptr<DrmDevice>& drm,
     uint32_t crtc) {
   HardwareDisplayControllers::iterator it = FindDisplayController(drm, crtc);
   if (it != controllers_.end()) {
     HardwareDisplayController* controller = *it;
     if (controller->IsMirrored()) {
       controller = new HardwareDisplayController(
@@ skipping 67 matching lines @@
   }
 
   return controllers_.end();
 }
 
 bool ScreenManager::HandleMirrorMode(
     HardwareDisplayControllers::iterator original,
     HardwareDisplayControllers::iterator mirror,
     const scoped_refptr<DrmDevice>& drm,
     uint32_t crtc,
-    uint32_t connector) {
-  (*mirror)->AddCrtc((*original)->RemoveCrtc(drm, crtc));
-  if (EnableController(*mirror, (*mirror)->origin(), (*mirror)->get_mode())) {
+    uint32_t connector,
+    const drmModeModeInfo& mode) {
+  gfx::Point last_origin = (*original)->origin();
+  // There should only be one CRTC in this controller.
+  drmModeModeInfo last_mode = (*original)->crtc_controllers()[0]->mode();
+
+  // Modeset the CRTC with its mode in the original controller so that only this
+  // CRTC is affected by the mode. Otherwise it could apply a mode with the same
+  // resolution and refresh rate but with different timings to the other CRTC.
+  // TODO(dnicoara): This is hacky, instead the DrmDisplay and CrtcController
+  // should be merged and picking the mode should be done properly within
+  // HardwareDisplayController.
+  if (ModesetController(*original, (*mirror)->origin(), mode)) {
+    (*mirror)->AddCrtc((*original)->RemoveCrtc(drm, crtc));
     controllers_.erase(original);
     return true;
   }
 
   LOG(ERROR) << "Failed to switch to mirror mode";
 
   // When things go wrong revert back to the previous configuration since
   // it is expected that the configuration would not have changed if
   // things fail.
-  (*original)->AddCrtc((*mirror)->RemoveCrtc(drm, crtc));
-  EnableController(*original, (*original)->origin(), (*original)->get_mode());
+  ModesetController(*original, last_origin, last_mode);
   return false;
 }
 
 void ScreenManager::UpdateControllerToWindowMapping() {
   std::map<DrmWindow*, HardwareDisplayController*> window_to_controller_map;
   // First create a unique mapping between a window and a controller. Note, a
   // controller may be associated with at most 1 window.
   for (HardwareDisplayController* controller : controllers_) {
     if (controller->IsDisabled())
       continue;
@@ skipping 13 matching lines @@
     if (it != window_to_controller_map.end())
       controller = it->second;
 
     bool should_enable =
         controller && pair.second->GetController() != controller;
     pair.second->SetController(controller);
 
     // If we're moving windows between controllers modeset the controller
     // otherwise the controller may be waiting for a page flip while the window
     // tries to schedule another buffer.
-    if (should_enable)
-      EnableController(controller, controller->origin(),
-                       controller->get_mode());
+    if (should_enable) {
+      EnableController(controller);
+    }
   }
 }
 
-bool ScreenManager::EnableController(HardwareDisplayController* controller,
-                                     const gfx::Point& origin,
-                                     const drmModeModeInfo& mode) {
+OverlayPlane ScreenManager::GetModesetBuffer(
+    HardwareDisplayController* controller,
+    const gfx::Rect& bounds) {
+  DrmWindow* window = FindWindowAt(bounds);
+  if (window) {
+    const OverlayPlane* primary = window->GetLastModesetBuffer();
+    if (primary && primary->buffer->GetSize() == bounds.size())
+      return *primary;
+  }
+
+  scoped_refptr<DrmDevice> drm = controller->GetAllocationDrmDevice();
+  scoped_refptr<ScanoutBuffer> buffer =
+      buffer_generator_->Create(drm, bounds.size());
+  if (!buffer) {
+    LOG(ERROR) << "Failed to create scanout buffer";
+    return OverlayPlane(nullptr, 0, gfx::OVERLAY_TRANSFORM_INVALID, gfx::Rect(),
+                        gfx::RectF());
+  }
+
+  FillModesetBuffer(drm, controller, buffer.get());
+  return OverlayPlane(buffer);
+}
+
+bool ScreenManager::EnableController(HardwareDisplayController* controller) {
+  DCHECK(!controller->crtc_controllers().empty());
+  gfx::Rect rect(controller->origin(), controller->GetModeSize());
+  OverlayPlane plane = GetModesetBuffer(controller, rect);
+  if (!plane.buffer || !controller->Enable(plane)) {
+    LOG(ERROR) << "Failed to enable controller";
+    return false;
+  }
+
+  return true;
+}
+
+bool ScreenManager::ModesetController(HardwareDisplayController* controller,
+                                      const gfx::Point& origin,
+                                      const drmModeModeInfo& mode) {
   DCHECK(!controller->crtc_controllers().empty());
   gfx::Rect rect(origin, gfx::Size(mode.hdisplay, mode.vdisplay));
   controller->set_origin(origin);
 
-  DrmWindow* window = FindWindowAt(rect);
-  if (window) {
-    const OverlayPlane* primary = window->GetLastModesetBuffer();
-    if (primary) {
-      if (!controller->Modeset(*primary, mode)) {
-        LOG(ERROR) << "Failed to modeset controller";
-        return false;
-      }
-
-      return true;
-    }
-  }
-
-  scoped_refptr<DrmDevice> drm = controller->GetAllocationDrmDevice();
-  scoped_refptr<ScanoutBuffer> buffer =
-      buffer_generator_->Create(drm, rect.size());
-  if (!buffer) {
-    LOG(ERROR) << "Failed to create scanout buffer";
-    return false;
-  }
-
-  FillModesetBuffer(drm, controller, buffer.get());
-  if (!controller->Modeset(OverlayPlane(buffer), mode)) {
+  OverlayPlane plane = GetModesetBuffer(controller, rect);
+  if (!plane.buffer || !controller->Modeset(plane, mode)) {
     LOG(ERROR) << "Failed to modeset controller";
     return false;
   }
 
   return true;
 }
 
 DrmWindow* ScreenManager::FindWindowAt(const gfx::Rect& bounds) const {
   for (auto pair : window_map_) {
     if (pair.second->bounds() == bounds)
       return pair.second;
   }
 
   return nullptr;
 }
 
 }  // namespace ui