src/ui/display/chromeos/x11/native_display_delegate_x11.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/display/chromeos/x11/native_display_delegate_x11.h"
   6
   7 #include <X11/Xatom.h>
   8 #include <X11/Xlib.h>
   9 #include <X11/extensions/dpms.h>
  10 #include <X11/extensions/Xrandr.h>
  11 #include <X11/extensions/XInput2.h>
  12
  13 #include <utility>
  14
  15 #include "base/logging.h"
  16 #include "base/stl_util.h"
  17 #include "ui/display/chromeos/x11/display_mode_x11.h"
  18 #include "ui/display/chromeos/x11/display_snapshot_x11.h"
  19 #include "ui/display/chromeos/x11/display_util_x11.h"
  20 #include "ui/display/chromeos/x11/native_display_event_dispatcher_x11.h"
  21 #include "ui/display/types/chromeos/native_display_observer.h"
  22 #include "ui/display/util/x11/edid_parser_x11.h"
  23 #include "ui/events/platform/platform_event_observer.h"
  24 #include "ui/events/platform/platform_event_source.h"
  25 #include "ui/gfx/geometry/rect.h"
  26 #include "ui/gfx/x/x11_error_tracker.h"
  27 #include "ui/gfx/x/x11_types.h"
  28
  29 namespace ui {
  30
  31 namespace {
  32
  33 // DPI measurements.
  34 const float kMmInInch = 25.4;
  35 const float kDpi96 = 96.0;
  36 const float kPixelsToMmScale = kMmInInch / kDpi96;
  37
  38 const char kContentProtectionAtomName[] = "Content Protection";
  39 const char kProtectionUndesiredAtomName[] = "Undesired";
  40 const char kProtectionDesiredAtomName[] = "Desired";
  41 const char kProtectionEnabledAtomName[] = "Enabled";
  42
  43 RRMode GetOutputNativeMode(const XRROutputInfo* output_info) {
  44   return output_info->nmode > 0 ? output_info->modes[0] : None;
  45 }
  46
  47 XRRCrtcGamma* ResampleGammaRamp(XRRCrtcGamma* gamma_ramp, int gamma_ramp_size) {
  48   if (gamma_ramp->size == gamma_ramp_size)
  49     return gamma_ramp;
  50
  51 #define RESAMPLE(array, i, r) \
  52   array[i] + (array[i + 1] - array[i]) * r / gamma_ramp_size
  53
  54   XRRCrtcGamma* resampled = XRRAllocGamma(gamma_ramp_size);
  55   for (int i = 0; i < gamma_ramp_size; ++i) {
  56     int base_index = gamma_ramp->size * i / gamma_ramp_size;
  57     int remaining = gamma_ramp->size * i % gamma_ramp_size;
  58     if (base_index < gamma_ramp->size - 1) {
  59       resampled->red[i] = RESAMPLE(gamma_ramp->red, base_index, remaining);
  60       resampled->green[i] = RESAMPLE(gamma_ramp->green, base_index, remaining);
  61       resampled->blue[i] = RESAMPLE(gamma_ramp->blue, base_index, remaining);
  62     } else {
  63       resampled->red[i] = gamma_ramp->red[gamma_ramp->size - 1];
  64       resampled->green[i] = gamma_ramp->green[gamma_ramp->size - 1];
  65       resampled->blue[i] = gamma_ramp->blue[gamma_ramp->size - 1];
  66     }
  67   }
  68
  69 #undef RESAMPLE
  70   XRRFreeGamma(gamma_ramp);
  71   return resampled;
  72 }
  73
  74 }  // namespace
  75
  76 ////////////////////////////////////////////////////////////////////////////////
  77 // NativeDisplayDelegateX11::HelperDelegateX11
  78
  79 class NativeDisplayDelegateX11::HelperDelegateX11
  80     : public NativeDisplayDelegateX11::HelperDelegate {
  81  public:
  82   HelperDelegateX11(NativeDisplayDelegateX11* delegate) : delegate_(delegate) {}
  83   virtual ~HelperDelegateX11() {}
  84
  85   // NativeDisplayDelegateX11::HelperDelegate overrides:
  86   virtual void UpdateXRandRConfiguration(const base::NativeEvent& event)
  87       OVERRIDE {
  88     XRRUpdateConfiguration(event);
  89   }
  90   virtual const std::vector<DisplaySnapshot*>& GetCachedDisplays() const
  91       OVERRIDE {
  92     return delegate_->cached_outputs_.get();
  93   }
  94   virtual void NotifyDisplayObservers() OVERRIDE {
  95     FOR_EACH_OBSERVER(
  96         NativeDisplayObserver, delegate_->observers_, OnConfigurationChanged());
  97   }
  98
  99  private:
 100   NativeDisplayDelegateX11* delegate_;
 101
 102   DISALLOW_COPY_AND_ASSIGN(HelperDelegateX11);
 103 };
 104
 105 ////////////////////////////////////////////////////////////////////////////////
 106 // NativeDisplayDelegateX11::PlatformEventObserverX11
 107
 108 class NativeDisplayDelegateX11::PlatformEventObserverX11
 109     : public PlatformEventObserver {
 110  public:
 111   PlatformEventObserverX11(HelperDelegate* delegate);
 112   virtual ~PlatformEventObserverX11();
 113
 114   // PlatformEventObserverX11:
 115   virtual void WillProcessEvent(const ui::PlatformEvent& event) OVERRIDE;
 116   virtual void DidProcessEvent(const ui::PlatformEvent& event) OVERRIDE;
 117
 118  private:
 119   HelperDelegate* delegate_;  // Not owned.
 120
 121   DISALLOW_COPY_AND_ASSIGN(PlatformEventObserverX11);
 122 };
 123
 124 NativeDisplayDelegateX11::PlatformEventObserverX11::PlatformEventObserverX11(
 125     HelperDelegate* delegate)
 126     : delegate_(delegate) {}
 127
 128 NativeDisplayDelegateX11::PlatformEventObserverX11::
 129     ~PlatformEventObserverX11() {}
 130
 131 void NativeDisplayDelegateX11::PlatformEventObserverX11::WillProcessEvent(
 132     const ui::PlatformEvent& event) {
 133   // XI_HierarchyChanged events are special. There is no window associated with
 134   // these events. So process them directly from here.
 135   if (event->type == GenericEvent &&
 136       event->xgeneric.evtype == XI_HierarchyChanged) {
 137     VLOG(1) << "Received XI_HierarchyChanged event";
 138     // Defer configuring outputs to not stall event processing.
 139     // This also takes care of same event being received twice.
 140     delegate_->NotifyDisplayObservers();
 141   }
 142 }
 143
 144 void NativeDisplayDelegateX11::PlatformEventObserverX11::DidProcessEvent(
 145     const ui::PlatformEvent& event) {}
 146
 147 ////////////////////////////////////////////////////////////////////////////////
 148 // NativeDisplayDelegateX11 implementation:
 149
 150 NativeDisplayDelegateX11::NativeDisplayDelegateX11()
 151     : display_(gfx::GetXDisplay()),
 152       window_(DefaultRootWindow(display_)),
 153       screen_(NULL),
 154       background_color_argb_(0) {}
 155
 156 NativeDisplayDelegateX11::~NativeDisplayDelegateX11() {
 157   if (ui::PlatformEventSource::GetInstance()) {
 158     ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(
 159         platform_event_dispatcher_.get());
 160     ui::PlatformEventSource::GetInstance()->RemovePlatformEventObserver(
 161         platform_event_observer_.get());
 162   }
 163
 164   STLDeleteContainerPairSecondPointers(modes_.begin(), modes_.end());
 165 }
 166
 167 void NativeDisplayDelegateX11::Initialize() {
 168   int error_base_ignored = 0;
 169   int xrandr_event_base = 0;
 170   XRRQueryExtension(display_, &xrandr_event_base, &error_base_ignored);
 171
 172   helper_delegate_.reset(new HelperDelegateX11(this));
 173   platform_event_dispatcher_.reset(new NativeDisplayEventDispatcherX11(
 174       helper_delegate_.get(), xrandr_event_base));
 175   platform_event_observer_.reset(
 176       new PlatformEventObserverX11(helper_delegate_.get()));
 177
 178   if (ui::PlatformEventSource::GetInstance()) {
 179     ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(
 180         platform_event_dispatcher_.get());
 181
 182     // We can't do this with a root window listener because XI_HierarchyChanged
 183     // messages don't have a target window.
 184     ui::PlatformEventSource::GetInstance()->AddPlatformEventObserver(
 185         platform_event_observer_.get());
 186   }
 187 }
 188
 189 void NativeDisplayDelegateX11::GrabServer() {
 190   CHECK(!screen_) << "Server already grabbed";
 191   XGrabServer(display_);
 192   screen_ = XRRGetScreenResources(display_, window_);
 193   CHECK(screen_);
 194 }
 195
 196 void NativeDisplayDelegateX11::UngrabServer() {
 197   CHECK(screen_) << "Server not grabbed";
 198   XRRFreeScreenResources(screen_);
 199   screen_ = NULL;
 200   XUngrabServer(display_);
 201   // crbug.com/366125
 202   XFlush(display_);
 203 }
 204
 205 void NativeDisplayDelegateX11::SyncWithServer() { XSync(display_, 0); }
 206
 207 void NativeDisplayDelegateX11::SetBackgroundColor(uint32_t color_argb) {
 208   background_color_argb_ = color_argb;
 209 }
 210
 211 void NativeDisplayDelegateX11::ForceDPMSOn() {
 212   CHECK(DPMSEnable(display_));
 213   CHECK(DPMSForceLevel(display_, DPMSModeOn));
 214 }
 215
 216 std::vector<DisplaySnapshot*> NativeDisplayDelegateX11::GetDisplays() {
 217   CHECK(screen_) << "Server not grabbed";
 218
 219   cached_outputs_.clear();
 220   RRCrtc last_used_crtc = None;
 221
 222   InitModes();
 223   for (int i = 0; i < screen_->noutput && cached_outputs_.size() < 2; ++i) {
 224     RROutput output_id = screen_->outputs[i];
 225     XRROutputInfo* output_info = XRRGetOutputInfo(display_, screen_, output_id);
 226     if (output_info->connection == RR_Connected) {
 227       DisplaySnapshotX11* output =
 228           InitDisplaySnapshot(output_id, output_info, &last_used_crtc, i);
 229       cached_outputs_.push_back(output);
 230     }
 231     XRRFreeOutputInfo(output_info);
 232   }
 233
 234   return cached_outputs_.get();
 235 }
 236
 237 void NativeDisplayDelegateX11::AddMode(const DisplaySnapshot& output,
 238                                        const DisplayMode* mode) {
 239   CHECK(screen_) << "Server not grabbed";
 240   CHECK(mode) << "Must add valid mode";
 241
 242   const DisplaySnapshotX11& x11_output =
 243       static_cast<const DisplaySnapshotX11&>(output);
 244   RRMode mode_id = static_cast<const DisplayModeX11*>(mode)->mode_id();
 245
 246   VLOG(1) << "AddDisplayMode: output=" << x11_output.output()
 247           << " mode=" << mode_id;
 248   XRRAddOutputMode(display_, x11_output.output(), mode_id);
 249 }
 250
 251 bool NativeDisplayDelegateX11::Configure(const DisplaySnapshot& output,
 252                                          const DisplayMode* mode,
 253                                          const gfx::Point& origin) {
 254   const DisplaySnapshotX11& x11_output =
 255       static_cast<const DisplaySnapshotX11&>(output);
 256   RRMode mode_id = None;
 257   if (mode)
 258     mode_id = static_cast<const DisplayModeX11*>(mode)->mode_id();
 259
 260   return ConfigureCrtc(
 261       x11_output.crtc(), mode_id, x11_output.output(), origin.x(), origin.y());
 262 }
 263
 264 bool NativeDisplayDelegateX11::ConfigureCrtc(RRCrtc crtc,
 265                                              RRMode mode,
 266                                              RROutput output,
 267                                              int x,
 268                                              int y) {
 269   CHECK(screen_) << "Server not grabbed";
 270   VLOG(1) << "ConfigureCrtc: crtc=" << crtc << " mode=" << mode
 271           << " output=" << output << " x=" << x << " y=" << y;
 272   // Xrandr.h is full of lies. XRRSetCrtcConfig() is defined as returning a
 273   // Status, which is typically 0 for failure and 1 for success. In
 274   // actuality it returns a RRCONFIGSTATUS, which uses 0 for success.
 275   if (XRRSetCrtcConfig(display_,
 276                        screen_,
 277                        crtc,
 278                        CurrentTime,
 279                        x,
 280                        y,
 281                        mode,
 282                        RR_Rotate_0,
 283                        (output && mode) ? &output : NULL,
 284                        (output && mode) ? 1 : 0) != RRSetConfigSuccess) {
 285     LOG(WARNING) << "Unable to configure CRTC " << crtc << ":"
 286                  << " mode=" << mode << " output=" << output << " x=" << x
 287                  << " y=" << y;
 288     return false;
 289   }
 290
 291   return true;
 292 }
 293
 294 void NativeDisplayDelegateX11::CreateFrameBuffer(const gfx::Size& size) {
 295   CHECK(screen_) << "Server not grabbed";
 296   gfx::Size current_screen_size(
 297       DisplayWidth(display_, DefaultScreen(display_)),
 298       DisplayHeight(display_, DefaultScreen(display_)));
 299
 300   VLOG(1) << "CreateFrameBuffer: new=" << size.ToString()
 301           << " current=" << current_screen_size.ToString();
 302
 303   DestroyUnusedCrtcs();
 304
 305   if (size == current_screen_size)
 306     return;
 307
 308   gfx::Size min_screen_size(current_screen_size);
 309   min_screen_size.SetToMin(size);
 310   UpdateCrtcsForNewFramebuffer(min_screen_size);
 311
 312   int mm_width = size.width() * kPixelsToMmScale;
 313   int mm_height = size.height() * kPixelsToMmScale;
 314   XRRSetScreenSize(
 315       display_, window_, size.width(), size.height(), mm_width, mm_height);
 316   // We don't wait for root window resize, therefore this end up with drawing
 317   // in the old window size, which we care during the boot.
 318   DrawBackground();
 319
 320   // Don't redraw the background upon framebuffer change again. This should
 321   // happen only once after boot.
 322   background_color_argb_ = 0;
 323 }
 324
 325 void NativeDisplayDelegateX11::AddObserver(NativeDisplayObserver* observer) {
 326   observers_.AddObserver(observer);
 327 }
 328
 329 void NativeDisplayDelegateX11::RemoveObserver(NativeDisplayObserver* observer) {
 330   observers_.RemoveObserver(observer);
 331 }
 332
 333 void NativeDisplayDelegateX11::InitModes() {
 334   CHECK(screen_) << "Server not grabbed";
 335
 336   STLDeleteContainerPairSecondPointers(modes_.begin(), modes_.end());
 337   modes_.clear();
 338
 339   for (int i = 0; i < screen_->nmode; ++i) {
 340     const XRRModeInfo& info = screen_->modes[i];
 341     float refresh_rate = 0.0f;
 342     if (info.hTotal && info.vTotal) {
 343       refresh_rate =
 344           static_cast<float>(info.dotClock) /
 345           (static_cast<float>(info.hTotal) * static_cast<float>(info.vTotal));
 346     }
 347
 348     modes_.insert(
 349         std::make_pair(info.id,
 350                        new DisplayModeX11(gfx::Size(info.width, info.height),
 351                                           info.modeFlags & RR_Interlace,
 352                                           refresh_rate,
 353                                           info.id)));
 354   }
 355 }
 356
 357 DisplaySnapshotX11* NativeDisplayDelegateX11::InitDisplaySnapshot(
 358     RROutput id,
 359     XRROutputInfo* info,
 360     RRCrtc* last_used_crtc,
 361     int index) {
 362   int64_t display_id = 0;
 363   bool has_display_id = GetDisplayId(
 364       id, static_cast<uint8_t>(index), &display_id);
 365
 366   bool has_overscan = false;
 367   GetOutputOverscanFlag(id, &has_overscan);
 368
 369   DisplayConnectionType type = GetDisplayConnectionTypeFromName(info->name);
 370   if (type == DISPLAY_CONNECTION_TYPE_UNKNOWN)
 371     LOG(ERROR) << "Unknown link type: " << info->name;
 372
 373   // Use the index as a valid display ID even if the internal
 374   // display doesn't have valid EDID because the index
 375   // will never change.
 376   if (!has_display_id) {
 377     if (type == DISPLAY_CONNECTION_TYPE_INTERNAL)
 378       has_display_id = true;
 379
 380     // Fallback to output index.
 381     display_id = index;
 382   }
 383
 384   RRMode native_mode_id = GetOutputNativeMode(info);
 385   RRMode current_mode_id = None;
 386   gfx::Point origin;
 387   if (info->crtc) {
 388     XRRCrtcInfo* crtc_info = XRRGetCrtcInfo(display_, screen_, info->crtc);
 389     current_mode_id = crtc_info->mode;
 390     origin.SetPoint(crtc_info->x, crtc_info->y);
 391     XRRFreeCrtcInfo(crtc_info);
 392   }
 393
 394   RRCrtc crtc = None;
 395   // Assign a CRTC that isn't already in use.
 396   for (int i = 0; i < info->ncrtc; ++i) {
 397     if (info->crtcs[i] != *last_used_crtc) {
 398       crtc = info->crtcs[i];
 399       *last_used_crtc = crtc;
 400       break;
 401     }
 402   }
 403
 404   const DisplayMode* current_mode = NULL;
 405   const DisplayMode* native_mode = NULL;
 406   std::vector<const DisplayMode*> display_modes;
 407
 408   for (int i = 0; i < info->nmode; ++i) {
 409     const RRMode mode = info->modes[i];
 410     if (modes_.find(mode) != modes_.end()) {
 411       display_modes.push_back(modes_.at(mode));
 412
 413       if (mode == current_mode_id)
 414         current_mode = display_modes.back();
 415       if (mode == native_mode_id)
 416         native_mode = display_modes.back();
 417     } else {
 418       LOG(WARNING) << "Unable to find XRRModeInfo for mode " << mode;
 419     }
 420   }
 421
 422   DisplaySnapshotX11* output =
 423       new DisplaySnapshotX11(display_id,
 424                              has_display_id,
 425                              origin,
 426                              gfx::Size(info->mm_width, info->mm_height),
 427                              type,
 428                              IsOutputAspectPreservingScaling(id),
 429                              has_overscan,
 430                              GetDisplayName(id),
 431                              display_modes,
 432                              current_mode,
 433                              native_mode,
 434                              id,
 435                              crtc,
 436                              index);
 437
 438   VLOG(2) << "Found display " << cached_outputs_.size() << ":"
 439           << " output=" << output << " crtc=" << crtc
 440           << " current_mode=" << current_mode_id;
 441
 442   return output;
 443 }
 444
 445 bool NativeDisplayDelegateX11::GetHDCPState(const DisplaySnapshot& output,
 446                                             HDCPState* state) {
 447   unsigned char* values = NULL;
 448   int actual_format = 0;
 449   unsigned long nitems = 0;
 450   unsigned long bytes_after = 0;
 451   Atom actual_type = None;
 452   int success = 0;
 453   RROutput output_id = static_cast<const DisplaySnapshotX11&>(output).output();
 454   // TODO(kcwu): Use X11AtomCache to save round trip time of XInternAtom.
 455   Atom prop = XInternAtom(display_, kContentProtectionAtomName, False);
 456
 457   bool ok = true;
 458   // TODO(kcwu): Move this to x11_util (similar method calls in this file and
 459   // output_util.cc)
 460   success = XRRGetOutputProperty(display_,
 461                                  output_id,
 462                                  prop,
 463                                  0,
 464                                  100,
 465                                  False,
 466                                  False,
 467                                  AnyPropertyType,
 468                                  &actual_type,
 469                                  &actual_format,
 470                                  &nitems,
 471                                  &bytes_after,
 472                                  &values);
 473   if (actual_type == None) {
 474     LOG(ERROR) << "Property '" << kContentProtectionAtomName
 475                << "' does not exist";
 476     ok = false;
 477   } else if (success == Success && actual_type == XA_ATOM &&
 478              actual_format == 32 && nitems == 1) {
 479     Atom value = reinterpret_cast<Atom*>(values)[0];
 480     if (value == XInternAtom(display_, kProtectionUndesiredAtomName, False)) {
 481       *state = HDCP_STATE_UNDESIRED;
 482     } else if (value ==
 483                XInternAtom(display_, kProtectionDesiredAtomName, False)) {
 484       *state = HDCP_STATE_DESIRED;
 485     } else if (value ==
 486                XInternAtom(display_, kProtectionEnabledAtomName, False)) {
 487       *state = HDCP_STATE_ENABLED;
 488     } else {
 489       LOG(ERROR) << "Unknown " << kContentProtectionAtomName
 490                  << " value: " << value;
 491       ok = false;
 492     }
 493   } else {
 494     LOG(ERROR) << "XRRGetOutputProperty failed";
 495     ok = false;
 496   }
 497   if (values)
 498     XFree(values);
 499
 500   VLOG(3) << "HDCP state: " << ok << "," << *state;
 501   return ok;
 502 }
 503
 504 bool NativeDisplayDelegateX11::SetHDCPState(const DisplaySnapshot& output,
 505                                             HDCPState state) {
 506   Atom name = XInternAtom(display_, kContentProtectionAtomName, False);
 507   Atom value = None;
 508   switch (state) {
 509     case HDCP_STATE_UNDESIRED:
 510       value = XInternAtom(display_, kProtectionUndesiredAtomName, False);
 511       break;
 512     case HDCP_STATE_DESIRED:
 513       value = XInternAtom(display_, kProtectionDesiredAtomName, False);
 514       break;
 515     default:
 516       NOTREACHED() << "Invalid HDCP state: " << state;
 517       return false;
 518   }
 519   gfx::X11ErrorTracker err_tracker;
 520   unsigned char* data = reinterpret_cast<unsigned char*>(&value);
 521   RROutput output_id = static_cast<const DisplaySnapshotX11&>(output).output();
 522   XRRChangeOutputProperty(
 523       display_, output_id, name, XA_ATOM, 32, PropModeReplace, data, 1);
 524   if (err_tracker.FoundNewError()) {
 525     LOG(ERROR) << "XRRChangeOutputProperty failed";
 526     return false;
 527   } else {
 528     return true;
 529   }
 530 }
 531
 532 void NativeDisplayDelegateX11::DestroyUnusedCrtcs() {
 533   CHECK(screen_) << "Server not grabbed";
 534
 535   for (int i = 0; i < screen_->ncrtc; ++i) {
 536     bool in_use = false;
 537     for (ScopedVector<DisplaySnapshot>::const_iterator it =
 538              cached_outputs_.begin();
 539          it != cached_outputs_.end();
 540          ++it) {
 541       DisplaySnapshotX11* x11_output = static_cast<DisplaySnapshotX11*>(*it);
 542       if (screen_->crtcs[i] == x11_output->crtc()) {
 543         in_use = true;
 544         break;
 545       }
 546     }
 547
 548     if (!in_use)
 549       ConfigureCrtc(screen_->crtcs[i], None, None, 0, 0);
 550   }
 551 }
 552
 553 void NativeDisplayDelegateX11::UpdateCrtcsForNewFramebuffer(
 554     const gfx::Size& min_screen_size) {
 555   CHECK(screen_) << "Server not grabbed";
 556   // Setting the screen size will fail if any CRTC doesn't fit afterwards.
 557   // At the same time, turning CRTCs off and back on uses up a lot of time.
 558   // This function tries to be smart to avoid too many off/on cycles:
 559   // - We set the new modes on CRTCs, if they fit in both the old and new
 560   //   FBs, and park them at (0,0)
 561   // - We disable the CRTCs we will need but don't fit in the old FB. Those
 562   //   will be reenabled after the resize.
 563   // We don't worry about the cached state of the outputs here since we are
 564   // not interested in the state we are setting - we just try to get the CRTCs
 565   // out of the way so we can rebuild the frame buffer.
 566   gfx::Rect fb_rect(min_screen_size);
 567   for (ScopedVector<DisplaySnapshot>::const_iterator it =
 568            cached_outputs_.begin();
 569        it != cached_outputs_.end();
 570        ++it) {
 571     DisplaySnapshotX11* x11_output = static_cast<DisplaySnapshotX11*>(*it);
 572     const DisplayMode* mode_info = x11_output->current_mode();
 573     RROutput output = x11_output->output();
 574     RRMode mode = None;
 575
 576     if (mode_info) {
 577       mode = static_cast<const DisplayModeX11*>(mode_info)->mode_id();
 578
 579       if (!fb_rect.Contains(gfx::Rect(mode_info->size()))) {
 580         // In case our CRTC doesn't fit in common area of our current and about
 581         // to be resized framebuffer, disable it.
 582         // It'll get reenabled after we resize the framebuffer.
 583         mode = None;
 584         output = None;
 585         mode_info = NULL;
 586       }
 587     }
 588
 589     ConfigureCrtc(x11_output->crtc(), mode, output, 0, 0);
 590   }
 591 }
 592
 593 bool NativeDisplayDelegateX11::IsOutputAspectPreservingScaling(RROutput id) {
 594   bool ret = false;
 595
 596   Atom scaling_prop = XInternAtom(display_, "scaling mode", False);
 597   Atom full_aspect_atom = XInternAtom(display_, "Full aspect", False);
 598   if (scaling_prop == None || full_aspect_atom == None)
 599     return false;
 600
 601   int nprop = 0;
 602   Atom* props = XRRListOutputProperties(display_, id, &nprop);
 603   for (int j = 0; j < nprop && !ret; j++) {
 604     Atom prop = props[j];
 605     if (scaling_prop == prop) {
 606       unsigned char* values = NULL;
 607       int actual_format;
 608       unsigned long nitems;
 609       unsigned long bytes_after;
 610       Atom actual_type;
 611       int success;
 612
 613       success = XRRGetOutputProperty(display_,
 614                                      id,
 615                                      prop,
 616                                      0,
 617                                      100,
 618                                      False,
 619                                      False,
 620                                      AnyPropertyType,
 621                                      &actual_type,
 622                                      &actual_format,
 623                                      &nitems,
 624                                      &bytes_after,
 625                                      &values);
 626       if (success == Success && actual_type == XA_ATOM && actual_format == 32 &&
 627           nitems == 1) {
 628         Atom value = reinterpret_cast<Atom*>(values)[0];
 629         if (full_aspect_atom == value)
 630           ret = true;
 631       }
 632       if (values)
 633         XFree(values);
 634     }
 635   }
 636   if (props)
 637     XFree(props);
 638
 639   return ret;
 640 }
 641
 642
 643 std::vector<ColorCalibrationProfile>
 644 NativeDisplayDelegateX11::GetAvailableColorCalibrationProfiles(
 645     const DisplaySnapshot& output) {
 646   // TODO(mukai|marcheu): Checks the system data and fills the result.
 647   // Note that the order would be Dynamic -> Standard -> Movie -> Reading.
 648   return std::vector<ColorCalibrationProfile>();
 649 }
 650
 651 bool NativeDisplayDelegateX11::SetColorCalibrationProfile(
 652     const DisplaySnapshot& output,
 653     ColorCalibrationProfile new_profile) {
 654   const DisplaySnapshotX11& x11_output =
 655       static_cast<const DisplaySnapshotX11&>(output);
 656
 657   XRRCrtcGamma* gamma_ramp = CreateGammaRampForProfile(x11_output, new_profile);
 658
 659   if (!gamma_ramp)
 660     return false;
 661
 662   int gamma_ramp_size = XRRGetCrtcGammaSize(display_, x11_output.crtc());
 663   XRRSetCrtcGamma(display_,
 664                   x11_output.crtc(),
 665                   ResampleGammaRamp(gamma_ramp, gamma_ramp_size));
 666   XRRFreeGamma(gamma_ramp);
 667   return true;
 668 }
 669
 670 XRRCrtcGamma* NativeDisplayDelegateX11::CreateGammaRampForProfile(
 671     const DisplaySnapshotX11& x11_output,
 672     ColorCalibrationProfile new_profile) {
 673   // TODO(mukai|marcheu): Creates the appropriate gamma ramp data from the
 674   // profile enum. It would be served by the vendor.
 675   return NULL;
 676 }
 677
 678 void NativeDisplayDelegateX11::DrawBackground() {
 679   if (!background_color_argb_)
 680     return;
 681   // Configuring CRTCs/Framebuffer clears the boot screen image.  Paint the
 682   // same background color after updating framebuffer to minimize the
 683   // duration of black screen at boot time.
 684   XColor color;
 685   Colormap colormap = DefaultColormap(display_, 0);
 686   // XColor uses 16 bits per color.
 687   color.red = (background_color_argb_ & 0x00FF0000) >> 8;
 688   color.green = (background_color_argb_ & 0x0000FF00);
 689   color.blue = (background_color_argb_ & 0x000000FF) << 8;
 690   color.flags = DoRed | DoGreen | DoBlue;
 691   XAllocColor(display_, colormap, &color);
 692
 693   GC gc = XCreateGC(display_, window_, 0, 0);
 694   XSetForeground(display_, gc, color.pixel);
 695   XSetFillStyle(display_, gc, FillSolid);
 696   int width = DisplayWidth(display_, DefaultScreen(display_));
 697   int height = DisplayHeight(display_, DefaultScreen(display_));
 698   XFillRectangle(display_, window_, gc, 0, 0, width, height);
 699   XFreeGC(display_, gc);
 700   XFreeColors(display_, colormap, &color.pixel, 1, 0);
 701 }
 702
 703 }  // namespace ui