Home | History | Annotate | Download | only in chromeos 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ui/ozone/platform/dri/chromeos/native_display_delegate_dri.h"
      6 
      7 #include "base/bind.h"
      8 #include "ui/display/types/chromeos/native_display_observer.h"
      9 #include "ui/events/ozone/device/device_event.h"
     10 #include "ui/events/ozone/device/device_manager.h"
     11 #include "ui/ozone/platform/dri/chromeos/display_mode_dri.h"
     12 #include "ui/ozone/platform/dri/chromeos/display_snapshot_dri.h"
     13 #include "ui/ozone/platform/dri/dri_util.h"
     14 #include "ui/ozone/platform/dri/dri_wrapper.h"
     15 #include "ui/ozone/platform/dri/screen_manager.h"
     16 
     17 namespace ui {
     18 
     19 namespace {
     20 const size_t kMaxDisplayCount = 2;
     21 }  // namespace
     22 
     23 NativeDisplayDelegateDri::NativeDisplayDelegateDri(
     24     DriWrapper* dri,
     25     ScreenManager* screen_manager,
     26     DeviceManager* device_manager)
     27     : dri_(dri),
     28       screen_manager_(screen_manager),
     29       device_manager_(device_manager) {
     30 }
     31 
     32 NativeDisplayDelegateDri::~NativeDisplayDelegateDri() {
     33   device_manager_->RemoveObserver(this);
     34 }
     35 
     36 void NativeDisplayDelegateDri::Initialize() {
     37   device_manager_->AddObserver(this);
     38 }
     39 
     40 void NativeDisplayDelegateDri::GrabServer() {}
     41 
     42 void NativeDisplayDelegateDri::UngrabServer() {}
     43 
     44 void NativeDisplayDelegateDri::SyncWithServer() {}
     45 
     46 void NativeDisplayDelegateDri::SetBackgroundColor(uint32_t color_argb) {
     47   NOTIMPLEMENTED();
     48 }
     49 
     50 void NativeDisplayDelegateDri::ForceDPMSOn() {
     51   for (size_t i = 0; i < cached_displays_.size(); ++i) {
     52     DisplaySnapshotDri* dri_output = cached_displays_[i];
     53     if (dri_output->dpms_property())
     54       dri_->SetProperty(dri_output->connector(),
     55                         dri_output->dpms_property()->prop_id,
     56                         DRM_MODE_DPMS_ON);
     57   }
     58 }
     59 
     60 std::vector<DisplaySnapshot*> NativeDisplayDelegateDri::GetDisplays() {
     61   ScopedVector<DisplaySnapshotDri> old_displays(cached_displays_.Pass());
     62   cached_modes_.clear();
     63 
     64   drmModeRes* resources = drmModeGetResources(dri_->get_fd());
     65   DCHECK(resources) << "Failed to get DRM resources";
     66   ScopedVector<HardwareDisplayControllerInfo> displays =
     67       GetAvailableDisplayControllerInfos(dri_->get_fd(), resources);
     68   for (size_t i = 0;
     69        i < displays.size() && cached_displays_.size() < kMaxDisplayCount; ++i) {
     70     DisplaySnapshotDri* display = new DisplaySnapshotDri(
     71         dri_, displays[i]->connector(), displays[i]->crtc(), i);
     72     cached_displays_.push_back(display);
     73     // Modes can be shared between different displays, so we need to keep track
     74     // of them independently for cleanup.
     75     cached_modes_.insert(cached_modes_.end(),
     76                          display->modes().begin(),
     77                          display->modes().end());
     78   }
     79 
     80   drmModeFreeResources(resources);
     81 
     82   NotifyScreenManager(cached_displays_.get(), old_displays.get());
     83 
     84   std::vector<DisplaySnapshot*> generic_displays(cached_displays_.begin(),
     85                                                  cached_displays_.end());
     86   return generic_displays;
     87 }
     88 
     89 void NativeDisplayDelegateDri::AddMode(const DisplaySnapshot& output,
     90                                        const DisplayMode* mode) {}
     91 
     92 bool NativeDisplayDelegateDri::Configure(const DisplaySnapshot& output,
     93                                          const DisplayMode* mode,
     94                                          const gfx::Point& origin) {
     95   const DisplaySnapshotDri& dri_output =
     96       static_cast<const DisplaySnapshotDri&>(output);
     97 
     98   VLOG(1) << "DRM configuring: crtc=" << dri_output.crtc()
     99           << " connector=" << dri_output.connector()
    100           << " origin=" << origin.ToString()
    101           << " size=" << (mode ? mode->size().ToString() : "0x0");
    102 
    103   if (mode) {
    104     if (!screen_manager_->ConfigureDisplayController(
    105             dri_output.crtc(),
    106             dri_output.connector(),
    107             static_cast<const DisplayModeDri*>(mode)->mode_info())) {
    108       VLOG(1) << "Failed to configure: crtc=" << dri_output.crtc()
    109               << " connector=" << dri_output.connector();
    110       return false;
    111     }
    112   } else {
    113     if (!screen_manager_->DisableDisplayController(dri_output.crtc(),
    114                                                    dri_output.connector())) {
    115       VLOG(1) << "Failed to disable crtc=" << dri_output.crtc();
    116       return false;
    117     }
    118   }
    119 
    120   return true;
    121 }
    122 
    123 void NativeDisplayDelegateDri::CreateFrameBuffer(const gfx::Size& size) {}
    124 
    125 bool NativeDisplayDelegateDri::GetHDCPState(const DisplaySnapshot& output,
    126                                             HDCPState* state) {
    127   NOTIMPLEMENTED();
    128   return false;
    129 }
    130 
    131 bool NativeDisplayDelegateDri::SetHDCPState(const DisplaySnapshot& output,
    132                                             HDCPState state) {
    133   NOTIMPLEMENTED();
    134   return false;
    135 }
    136 
    137 std::vector<ui::ColorCalibrationProfile>
    138 NativeDisplayDelegateDri::GetAvailableColorCalibrationProfiles(
    139     const ui::DisplaySnapshot& output) {
    140   NOTIMPLEMENTED();
    141   return std::vector<ui::ColorCalibrationProfile>();
    142 }
    143 
    144 bool NativeDisplayDelegateDri::SetColorCalibrationProfile(
    145     const ui::DisplaySnapshot& output,
    146     ui::ColorCalibrationProfile new_profile) {
    147   NOTIMPLEMENTED();
    148   return false;
    149 }
    150 
    151 void NativeDisplayDelegateDri::AddObserver(NativeDisplayObserver* observer) {
    152   observers_.AddObserver(observer);
    153 }
    154 
    155 void NativeDisplayDelegateDri::RemoveObserver(NativeDisplayObserver* observer) {
    156   observers_.RemoveObserver(observer);
    157 }
    158 
    159 void NativeDisplayDelegateDri::OnDeviceEvent(const DeviceEvent& event) {
    160   if (event.device_type() != DeviceEvent::DISPLAY)
    161     return;
    162 
    163   if (event.action_type() == DeviceEvent::CHANGE) {
    164     VLOG(1) << "Got display changed event";
    165     FOR_EACH_OBSERVER(
    166         NativeDisplayObserver, observers_, OnConfigurationChanged());
    167   }
    168 }
    169 
    170 void NativeDisplayDelegateDri::NotifyScreenManager(
    171     const std::vector<DisplaySnapshotDri*>& new_displays,
    172     const std::vector<DisplaySnapshotDri*>& old_displays) const {
    173   for (size_t i = 0; i < old_displays.size(); ++i) {
    174     bool found = false;
    175     for (size_t j = 0; j < new_displays.size(); ++j) {
    176       if (old_displays[i]->connector() == new_displays[j]->connector() &&
    177           old_displays[i]->crtc() == new_displays[j]->crtc()) {
    178         found = true;
    179         break;
    180       }
    181     }
    182 
    183     if (!found)
    184       screen_manager_->RemoveDisplayController(old_displays[i]->crtc(),
    185                                                old_displays[i]->connector());
    186   }
    187 }
    188 
    189 }  // namespace ui
    190