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

ui/ozone/platform/drm/gpu/hardware_display_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/hardware_display_controller.h"
 
 #include <drm.h>
 #include <string.h>
 #include <xf86drm.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/swap_result.h"
 #include "ui/ozone/platform/drm/gpu/crtc_controller.h"
 #include "ui/ozone/platform/drm/gpu/drm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/page_flip_request.h"
 #include "ui/ozone/public/native_pixmap.h"
 
 namespace ui {
 
 HardwareDisplayController::HardwareDisplayController(
     scoped_ptr<CrtcController> controller,
     const gfx::Point& origin)
     : origin_(origin),
-      mode_(controller->mode()),
       is_disabled_(controller->is_disabled()) {
   AddCrtc(controller.Pass());
 }
 
 HardwareDisplayController::~HardwareDisplayController() {
   // Reset the cursor.
   UnsetCursor();
 }
 
 bool HardwareDisplayController::Modeset(const OverlayPlane& primary,
                                         drmModeModeInfo mode) {
   TRACE_EVENT0("drm", "HDC::Modeset");
   DCHECK(primary.buffer.get());
   bool status = true;
   for (size_t i = 0; i < crtc_controllers_.size(); ++i)
     status &= crtc_controllers_[i]->Modeset(primary, mode);
 
   is_disabled_ = false;
-  mode_ = mode;
 
   return status;
 }
+
+bool HardwareDisplayController::Enable(const OverlayPlane& primary) {
+  TRACE_EVENT0("drm", "HDC::Enable");
+  DCHECK(primary.buffer.get());
+  bool status = true;
+  for (size_t i = 0; i < crtc_controllers_.size(); ++i) {
+    status &=
+        crtc_controllers_[i]->Modeset(primary, crtc_controllers_[i]->mode());
+  }
+
+  is_disabled_ = false;
+
+  return status;
+}
 
 void HardwareDisplayController::Disable() {
   TRACE_EVENT0("drm", "HDC::Disable");
   for (size_t i = 0; i < crtc_controllers_.size(); ++i)
     crtc_controllers_[i]->Disable();
 
 
   is_disabled_ = true;
 }
 
@@ skipping 144 matching lines @@
 
 bool HardwareDisplayController::IsMirrored() const {
   return crtc_controllers_.size() > 1;
 }
 
 bool HardwareDisplayController::IsDisabled() const {
   return is_disabled_;
 }
 
 gfx::Size HardwareDisplayController::GetModeSize() const {
-  return gfx::Size(mode_.hdisplay, mode_.vdisplay);
+  // If there are multiple CRTCs they should all have the same size.
+  return gfx::Size(crtc_controllers_[0]->mode().hdisplay,
+                   crtc_controllers_[0]->mode().vdisplay);
 }
 
 uint64_t HardwareDisplayController::GetTimeOfLastFlip() const {
   uint64_t time = 0;
   for (size_t i = 0; i < crtc_controllers_.size(); ++i)
     if (time < crtc_controllers_[i]->time_of_last_flip())
       time = crtc_controllers_[i]->time_of_last_flip();
 
   return time;
 }
 
 scoped_refptr<DrmDevice> HardwareDisplayController::GetAllocationDrmDevice()
     const {
   DCHECK(!crtc_controllers_.empty());
   // TODO(dnicoara) When we support mirroring across DRM devices, figure out
   // which device should be used for allocations.
   return crtc_controllers_[0]->drm();
 }
 
 }  // namespace ui