src/ui/ozone/platform/dri/chromeos/native_display_delegate_dri.cc

   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 "third_party/skia/include/core/SkCanvas.h"
   9 #include "ui/display/types/native_display_observer.h"
  10 #include "ui/events/ozone/device/device_event.h"
  11 #include "ui/events/ozone/device/device_manager.h"
  12 #include "ui/ozone/platform/dri/chromeos/display_mode_dri.h"
  13 #include "ui/ozone/platform/dri/chromeos/display_snapshot_dri.h"
  14 #include "ui/ozone/platform/dri/dri_console_buffer.h"
  15 #include "ui/ozone/platform/dri/dri_util.h"
  16 #include "ui/ozone/platform/dri/dri_wrapper.h"
  17 #include "ui/ozone/platform/dri/screen_manager.h"
  18
  19 namespace ui {
  20
  21 namespace {
  22
  23 const size_t kMaxDisplayCount = 2;
  24
  25 const char kContentProtection[] = "Content Protection";
  26
  27 struct ContentProtectionMapping {
  28   const char* name;
  29   HDCPState state;
  30 };
  31
  32 const ContentProtectionMapping kContentProtectionStates[] = {
  33     {"Undesired", HDCP_STATE_UNDESIRED},
  34     {"Desired", HDCP_STATE_DESIRED},
  35     {"Enabled", HDCP_STATE_ENABLED}};
  36
  37 uint32_t GetContentProtectionValue(drmModePropertyRes* property,
  38                                    HDCPState state) {
  39   std::string name;
  40   for (size_t i = 0; i < arraysize(kContentProtectionStates); ++i) {
  41     if (kContentProtectionStates[i].state == state) {
  42       name = kContentProtectionStates[i].name;
  43       break;
  44     }
  45   }
  46
  47   for (int i = 0; i < property->count_enums; ++i)
  48     if (name == property->enums[i].name)
  49       return i;
  50
  51   NOTREACHED();
  52   return 0;
  53 }
  54
  55 class DisplaySnapshotComparator {
  56  public:
  57   DisplaySnapshotComparator(const DisplaySnapshotDri* snapshot)
  58       : snapshot_(snapshot) {}
  59
  60   bool operator()(const DisplaySnapshotDri* other) const {
  61     if (snapshot_->connector() == other->connector() &&
  62         snapshot_->crtc() == other->crtc())
  63       return true;
  64
  65     return false;
  66   }
  67
  68  private:
  69   const DisplaySnapshotDri* snapshot_;
  70 };
  71
  72 }  // namespace
  73
  74 NativeDisplayDelegateDri::NativeDisplayDelegateDri(
  75     DriWrapper* dri,
  76     ScreenManager* screen_manager,
  77     DeviceManager* device_manager)
  78     : dri_(dri),
  79       screen_manager_(screen_manager),
  80       device_manager_(device_manager) {
  81   // TODO(dnicoara): Remove when async display configuration is supported.
  82   screen_manager_->ForceInitializationOfPrimaryDisplay();
  83 }
  84
  85 NativeDisplayDelegateDri::~NativeDisplayDelegateDri() {
  86   if (device_manager_)
  87     device_manager_->RemoveObserver(this);
  88 }
  89
  90 DisplaySnapshot* NativeDisplayDelegateDri::FindDisplaySnapshot(int64_t id) {
  91   for (size_t i = 0; i < cached_displays_.size(); ++i)
  92     if (cached_displays_[i]->display_id() == id)
  93       return cached_displays_[i];
  94
  95   return NULL;
  96 }
  97
  98 const DisplayMode* NativeDisplayDelegateDri::FindDisplayMode(
  99     const gfx::Size& size,
 100     bool is_interlaced,
 101     float refresh_rate) {
 102   for (size_t i = 0; i < cached_modes_.size(); ++i)
 103     if (cached_modes_[i]->size() == size &&
 104         cached_modes_[i]->is_interlaced() == is_interlaced &&
 105         cached_modes_[i]->refresh_rate() == refresh_rate)
 106       return cached_modes_[i];
 107
 108   return NULL;
 109 }
 110
 111 void NativeDisplayDelegateDri::Initialize() {
 112   if (device_manager_)
 113     device_manager_->AddObserver(this);
 114
 115   ScopedVector<HardwareDisplayControllerInfo> displays =
 116       GetAvailableDisplayControllerInfos(dri_->get_fd());
 117
 118   // By default all displays show the same console buffer.
 119   console_buffer_.reset(
 120       new DriConsoleBuffer(dri_, displays[0]->crtc()->buffer_id));
 121   if (!console_buffer_->Initialize()) {
 122     VLOG(1) << "Failed to initialize console buffer";
 123     console_buffer_.reset();
 124   } else {
 125     // Clear the console buffer such that restarting Chrome will show a
 126     // predetermined background.
 127     //
 128     // Black was chosen since Chrome's first buffer paints start with a black
 129     // background.
 130     console_buffer_->canvas()->clear(SK_ColorBLACK);
 131   }
 132 }
 133
 134 void NativeDisplayDelegateDri::GrabServer() {}
 135
 136 void NativeDisplayDelegateDri::UngrabServer() {}
 137
 138 void NativeDisplayDelegateDri::SyncWithServer() {}
 139
 140 void NativeDisplayDelegateDri::SetBackgroundColor(uint32_t color_argb) {
 141   if (console_buffer_)
 142     console_buffer_->canvas()->clear(color_argb);
 143 }
 144
 145 void NativeDisplayDelegateDri::ForceDPMSOn() {
 146   for (size_t i = 0; i < cached_displays_.size(); ++i) {
 147     DisplaySnapshotDri* dri_output = cached_displays_[i];
 148     if (dri_output->dpms_property())
 149       dri_->SetProperty(dri_output->connector(),
 150                         dri_output->dpms_property()->prop_id,
 151                         DRM_MODE_DPMS_ON);
 152   }
 153 }
 154
 155 std::vector<DisplaySnapshot*> NativeDisplayDelegateDri::GetDisplays() {
 156   ScopedVector<DisplaySnapshotDri> old_displays(cached_displays_.Pass());
 157   cached_modes_.clear();
 158
 159   ScopedVector<HardwareDisplayControllerInfo> displays =
 160       GetAvailableDisplayControllerInfos(dri_->get_fd());
 161   for (size_t i = 0;
 162        i < displays.size() && cached_displays_.size() < kMaxDisplayCount; ++i) {
 163     DisplaySnapshotDri* display = new DisplaySnapshotDri(
 164         dri_, displays[i]->connector(), displays[i]->crtc(), i);
 165     cached_displays_.push_back(display);
 166     cached_modes_.insert(cached_modes_.end(),
 167                          display->modes().begin(),
 168                          display->modes().end());
 169   }
 170
 171   NotifyScreenManager(cached_displays_.get(), old_displays.get());
 172
 173   std::vector<DisplaySnapshot*> generic_displays(cached_displays_.begin(),
 174                                                  cached_displays_.end());
 175   return generic_displays;
 176 }
 177
 178 void NativeDisplayDelegateDri::AddMode(const DisplaySnapshot& output,
 179                                        const DisplayMode* mode) {}
 180
 181 bool NativeDisplayDelegateDri::Configure(const DisplaySnapshot& output,
 182                                          const DisplayMode* mode,
 183                                          const gfx::Point& origin) {
 184   const DisplaySnapshotDri& dri_output =
 185       static_cast<const DisplaySnapshotDri&>(output);
 186
 187   VLOG(1) << "DRM configuring: crtc=" << dri_output.crtc()
 188           << " connector=" << dri_output.connector()
 189           << " origin=" << origin.ToString()
 190           << " size=" << (mode ? mode->size().ToString() : "0x0");
 191
 192   if (mode) {
 193     if (!screen_manager_->ConfigureDisplayController(
 194             dri_output.crtc(),
 195             dri_output.connector(),
 196             origin,
 197             static_cast<const DisplayModeDri*>(mode)->mode_info())) {
 198       VLOG(1) << "Failed to configure: crtc=" << dri_output.crtc()
 199               << " connector=" << dri_output.connector();
 200       return false;
 201     }
 202   } else {
 203     if (!screen_manager_->DisableDisplayController(dri_output.crtc())) {
 204       VLOG(1) << "Failed to disable crtc=" << dri_output.crtc();
 205       return false;
 206     }
 207   }
 208
 209   return true;
 210 }
 211
 212 void NativeDisplayDelegateDri::CreateFrameBuffer(const gfx::Size& size) {}
 213
 214 bool NativeDisplayDelegateDri::GetHDCPState(const DisplaySnapshot& output,
 215                                             HDCPState* state) {
 216   const DisplaySnapshotDri& dri_output =
 217       static_cast<const DisplaySnapshotDri&>(output);
 218
 219   ScopedDrmConnectorPtr connector(dri_->GetConnector(dri_output.connector()));
 220   if (!connector) {
 221     LOG(ERROR) << "Failed to get connector " << dri_output.connector();
 222     return false;
 223   }
 224
 225   ScopedDrmPropertyPtr hdcp_property(
 226       dri_->GetProperty(connector.get(), kContentProtection));
 227   if (!hdcp_property) {
 228     LOG(ERROR) << "'" << kContentProtection << "' property doesn't exist.";
 229     return false;
 230   }
 231
 232   DCHECK_LT(static_cast<int>(hdcp_property->prop_id), connector->count_props);
 233   int hdcp_state_idx = connector->prop_values[hdcp_property->prop_id];
 234   DCHECK_LT(hdcp_state_idx, hdcp_property->count_enums);
 235
 236   std::string name(hdcp_property->enums[hdcp_state_idx].name);
 237   for (size_t i = 0; i < arraysize(kContentProtectionStates); ++i) {
 238     if (name == kContentProtectionStates[i].name) {
 239       *state = kContentProtectionStates[i].state;
 240       VLOG(3) << "HDCP state: " << *state << " (" << name << ")";
 241       return true;
 242     }
 243   }
 244
 245   LOG(ERROR) << "Unknown content protection value '" << name << "'";
 246   return false;
 247 }
 248
 249 bool NativeDisplayDelegateDri::SetHDCPState(const DisplaySnapshot& output,
 250                                             HDCPState state) {
 251   const DisplaySnapshotDri& dri_output =
 252       static_cast<const DisplaySnapshotDri&>(output);
 253
 254   ScopedDrmConnectorPtr connector(dri_->GetConnector(dri_output.connector()));
 255   if (!connector) {
 256     LOG(ERROR) << "Failed to get connector " << dri_output.connector();
 257     return false;
 258   }
 259
 260   ScopedDrmPropertyPtr hdcp_property(
 261       dri_->GetProperty(connector.get(), kContentProtection));
 262   if (!hdcp_property) {
 263     LOG(ERROR) << "'" << kContentProtection << "' property doesn't exist.";
 264     return false;
 265   }
 266
 267   return dri_->SetProperty(
 268       dri_output.connector(),
 269       hdcp_property->prop_id,
 270       GetContentProtectionValue(hdcp_property.get(), state));
 271 }
 272
 273 std::vector<ui::ColorCalibrationProfile>
 274 NativeDisplayDelegateDri::GetAvailableColorCalibrationProfiles(
 275     const ui::DisplaySnapshot& output) {
 276   NOTIMPLEMENTED();
 277   return std::vector<ui::ColorCalibrationProfile>();
 278 }
 279
 280 bool NativeDisplayDelegateDri::SetColorCalibrationProfile(
 281     const ui::DisplaySnapshot& output,
 282     ui::ColorCalibrationProfile new_profile) {
 283   NOTIMPLEMENTED();
 284   return false;
 285 }
 286
 287 void NativeDisplayDelegateDri::AddObserver(NativeDisplayObserver* observer) {
 288   observers_.AddObserver(observer);
 289 }
 290
 291 void NativeDisplayDelegateDri::RemoveObserver(NativeDisplayObserver* observer) {
 292   observers_.RemoveObserver(observer);
 293 }
 294
 295 void NativeDisplayDelegateDri::OnDeviceEvent(const DeviceEvent& event) {
 296   if (event.device_type() != DeviceEvent::DISPLAY)
 297     return;
 298
 299   if (event.action_type() == DeviceEvent::CHANGE) {
 300     VLOG(1) << "Got display changed event";
 301     FOR_EACH_OBSERVER(
 302         NativeDisplayObserver, observers_, OnConfigurationChanged());
 303   }
 304 }
 305
 306 void NativeDisplayDelegateDri::NotifyScreenManager(
 307     const std::vector<DisplaySnapshotDri*>& new_displays,
 308     const std::vector<DisplaySnapshotDri*>& old_displays) const {
 309   for (size_t i = 0; i < old_displays.size(); ++i) {
 310     const std::vector<DisplaySnapshotDri*>::const_iterator it =
 311         std::find_if(new_displays.begin(),
 312                      new_displays.end(),
 313                      DisplaySnapshotComparator(old_displays[i]));
 314
 315     if (it == new_displays.end())
 316       screen_manager_->RemoveDisplayController(old_displays[i]->crtc());
 317   }
 318
 319   for (size_t i = 0; i < new_displays.size(); ++i) {
 320     const std::vector<DisplaySnapshotDri*>::const_iterator it =
 321         std::find_if(old_displays.begin(),
 322                      old_displays.end(),
 323                      DisplaySnapshotComparator(new_displays[i]));
 324
 325     if (it == old_displays.end())
 326       screen_manager_->AddDisplayController(new_displays[i]->crtc(),
 327                                             new_displays[i]->connector());
 328   }
 329 }
 330
 331 }  // namespace ui