Refactoring display configuration state to allow generic state objects

ui/display/chromeos/x11/native_display_delegate_x11.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 "chromeos/display/native_display_delegate_x11.h"
+#include "ui/display/chromeos/x11/native_display_delegate_x11.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/Xrandr.h>
 #include <X11/extensions/XInput2.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_pump_x11.h"
+#include "base/stl_util.h"
 #include "base/x11/edid_parser_x11.h"
 #include "base/x11/x11_error_tracker.h"
-#include "chromeos/display/native_display_event_dispatcher_x11.h"
-#include "chromeos/display/native_display_observer.h"
-#include "chromeos/display/output_util.h"
+#include "ui/display/chromeos/display_util.h"
+#include "ui/display/chromeos/native_display_observer.h"
+#include "ui/display/chromeos/x11/display_mode_x11.h"
+#include "ui/display/chromeos/x11/display_snapshot_x11.h"
+#include "ui/display/chromeos/x11/native_display_event_dispatcher_x11.h"
 
-namespace chromeos {
+namespace ui {
 
 namespace {
 
 // DPI measurements.
 const float kMmInInch = 25.4;
 const float kDpi96 = 96.0;
 const float kPixelsToMmScale = kMmInInch / kDpi96;
 
-// Prefixes of output name
-const char kOutputName_VGA[] = "VGA";
-const char kOutputName_HDMI[] = "HDMI";
-const char kOutputName_DVI[] = "DVI";
-const char kOutputName_DisplayPort[] = "DP";
-
 const char kContentProtectionAtomName[] = "Content Protection";
 const char kProtectionUndesiredAtomName[] = "Undesired";
 const char kProtectionDesiredAtomName[] = "Desired";
 const char kProtectionEnabledAtomName[] = "Enabled";
 
-bool IsInternalOutput(const XRROutputInfo* output_info) {
-  return IsInternalOutputName(std::string(output_info->name));
-}
-
 RRMode GetOutputNativeMode(const XRROutputInfo* output_info) {
   return output_info->nmode > 0 ? output_info->modes[0] : None;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeDisplayDelegateX11::HelperDelegateX11
 
 class NativeDisplayDelegateX11::HelperDelegateX11
     : public NativeDisplayDelegateX11::HelperDelegate {
  public:
-  HelperDelegateX11(NativeDisplayDelegateX11* delegate)
-      : delegate_(delegate) {}
+  HelperDelegateX11(NativeDisplayDelegateX11* delegate) : delegate_(delegate) {}
   virtual ~HelperDelegateX11() {}
 
   // NativeDisplayDelegateX11::HelperDelegate overrides:
-  virtual void UpdateXRandRConfiguration(
-      const base::NativeEvent& event) OVERRIDE {
+  virtual void UpdateXRandRConfiguration(const base::NativeEvent& event)
+      OVERRIDE {
     XRRUpdateConfiguration(event);
   }
-  virtual const std::vector<OutputConfigurator::OutputSnapshot>&
-      GetCachedOutputs() const OVERRIDE {
-    return delegate_->cached_outputs_;
+  virtual const std::vector<DisplaySnapshot*>& GetCachedOutputs() const
+      OVERRIDE {
+    return delegate_->cached_outputs_.get();
   }
   virtual void NotifyDisplayObservers() OVERRIDE {
-    FOR_EACH_OBSERVER(NativeDisplayObserver,
-                      delegate_->observers_,
-                      OnConfigurationChanged());
+    FOR_EACH_OBSERVER(
+        NativeDisplayObserver, delegate_->observers_, OnConfigurationChanged());
   }
 
  private:
   NativeDisplayDelegateX11* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(HelperDelegateX11);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeDisplayDelegateX11::MessagePumpObserverX11
 
 class NativeDisplayDelegateX11::MessagePumpObserverX11
     : public base::MessagePumpObserver {
  public:
   MessagePumpObserverX11(HelperDelegate* delegate);
   virtual ~MessagePumpObserverX11();
 
   // base::MessagePumpObserver overrides:
-  virtual base::EventStatus WillProcessEvent(
-      const base::NativeEvent& event) OVERRIDE;
+  virtual base::EventStatus WillProcessEvent(const base::NativeEvent& event)
+      OVERRIDE;
   virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE;
 
  private:
   HelperDelegate* delegate_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(MessagePumpObserverX11);
 };
 
 NativeDisplayDelegateX11::MessagePumpObserverX11::MessagePumpObserverX11(
-    HelperDelegate* delegate) : delegate_(delegate) {}
+    HelperDelegate* delegate)
+    : delegate_(delegate) {}
 
 NativeDisplayDelegateX11::MessagePumpObserverX11::~MessagePumpObserverX11() {}
 
 base::EventStatus
 NativeDisplayDelegateX11::MessagePumpObserverX11::WillProcessEvent(
     const base::NativeEvent& event) {
   // XI_HierarchyChanged events are special. There is no window associated with
   // these events. So process them directly from here.
   if (event->type == GenericEvent &&
       event->xgeneric.evtype == XI_HierarchyChanged) {
     VLOG(1) << "Received XI_HierarchyChanged event";
     // Defer configuring outputs to not stall event processing.
     // This also takes care of same event being received twice.
     delegate_->NotifyDisplayObservers();
   }
 
   return base::EVENT_CONTINUE;
 }
 
 void NativeDisplayDelegateX11::MessagePumpObserverX11::DidProcessEvent(
-    const base::NativeEvent& event) {
-}
+    const base::NativeEvent& event) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeDisplayDelegateX11 implementation:
 
 NativeDisplayDelegateX11::NativeDisplayDelegateX11()
     : display_(base::MessagePumpX11::GetDefaultXDisplay()),
       window_(DefaultRootWindow(display_)),
       screen_(NULL) {}
 
 NativeDisplayDelegateX11::~NativeDisplayDelegateX11() {
   base::MessagePumpX11::Current()->RemoveDispatcherForRootWindow(
       message_pump_dispatcher_.get());
   base::MessagePumpX11::Current()->RemoveObserver(message_pump_observer_.get());
+
+  STLDeleteContainerPairSecondPointers(modes_.begin(), modes_.end());
 }
 
 void NativeDisplayDelegateX11::Initialize() {
   int error_base_ignored = 0;
   int xrandr_event_base = 0;
   XRRQueryExtension(display_, &xrandr_event_base, &error_base_ignored);
 
   helper_delegate_.reset(new HelperDelegateX11(this));
   message_pump_dispatcher_.reset(new NativeDisplayEventDispatcherX11(
       helper_delegate_.get(), xrandr_event_base));
-  message_pump_observer_.reset(new MessagePumpObserverX11(
-      helper_delegate_.get()));
+  message_pump_observer_.reset(
+      new MessagePumpObserverX11(helper_delegate_.get()));
 
   base::MessagePumpX11::Current()->AddDispatcherForRootWindow(
       message_pump_dispatcher_.get());
   // We can't do this with a root window listener because XI_HierarchyChanged
   // messages don't have a target window.
   base::MessagePumpX11::Current()->AddObserver(message_pump_observer_.get());
 }
 
 void NativeDisplayDelegateX11::GrabServer() {
   CHECK(!screen_) << "Server already grabbed";
@@ skipping 28 matching lines @@
   swa.background_pixel = color.pixel;
   XChangeWindowAttributes(display_, window_, CWBackPixel, &swa);
   XFreeColors(display_, colormap, &color.pixel, 1, 0);
 }
 
 void NativeDisplayDelegateX11::ForceDPMSOn() {
   CHECK(DPMSEnable(display_));
   CHECK(DPMSForceLevel(display_, DPMSModeOn));
 }
 
-std::vector<OutputConfigurator::OutputSnapshot>
-NativeDisplayDelegateX11::GetOutputs() {
+std::vector<DisplaySnapshot*> NativeDisplayDelegateX11::GetOutputs() {
   CHECK(screen_) << "Server not grabbed";
 
   cached_outputs_.clear();
   RRCrtc last_used_crtc = None;
 
+  InitModes();
   for (int i = 0; i < screen_->noutput && cached_outputs_.size() < 2; ++i) {
     RROutput output_id = screen_->outputs[i];
     XRROutputInfo* output_info = XRRGetOutputInfo(display_, screen_, output_id);
     if (output_info->connection == RR_Connected) {
-      OutputConfigurator::OutputSnapshot output =
-          InitOutputSnapshot(output_id, output_info, &last_used_crtc, i);
-      VLOG(2) << "Found display " << cached_outputs_.size() << ":"
-              << " output=" << output.output << " crtc=" << output.crtc
-              << " current_mode=" << output.current_mode;
+      DisplaySnapshotX11* output =
+          InitDisplaySnapshot(output_id, output_info, &last_used_crtc, i);
       cached_outputs_.push_back(output);
     }
     XRRFreeOutputInfo(output_info);
   }
 
-  return cached_outputs_;
-}
-
-void NativeDisplayDelegateX11::AddMode(
-    const OutputConfigurator::OutputSnapshot& output, RRMode mode) {
-  CHECK(screen_) << "Server not grabbed";
-  VLOG(1) << "AddOutputMode: output=" << output.output << " mode=" << mode;
-  XRRAddOutputMode(display_, output.output, mode);
-}
-
-bool NativeDisplayDelegateX11::Configure(
-    const OutputConfigurator::OutputSnapshot& output,
-    RRMode mode,
-    int x,
-    int y) {
-  return ConfigureCrtc(output.crtc, mode, output.output, x, y);
-}
-
-bool NativeDisplayDelegateX11::ConfigureCrtc(
-    RRCrtc crtc,
-    RRMode mode,
-    RROutput output,
-    int x,
-    int y) {
+  return cached_outputs_.get();
+}
+
+void NativeDisplayDelegateX11::AddMode(const DisplaySnapshot& output,
+                                       const DisplayMode* mode) {
+  CHECK(screen_) << "Server not grabbed";
+
+  const DisplaySnapshotX11& x11_output =
+      static_cast<const DisplaySnapshotX11&>(output);
+  RRMode mode_id = static_cast<const DisplayModeX11*>(mode)->mode_id();
+
+  VLOG(1) << "AddOutputMode: output=" << x11_output.output()
+          << " mode=" << mode_id;
+  XRRAddOutputMode(display_, x11_output.output(), mode_id);
+}
+
+bool NativeDisplayDelegateX11::Configure(const DisplaySnapshot& output,
+                                         const DisplayMode* mode,
+                                         const gfx::Point& origin) {
+  const DisplaySnapshotX11& x11_output =
+      static_cast<const DisplaySnapshotX11&>(output);
+  RRMode mode_id = static_cast<const DisplayModeX11*>(mode)->mode_id();
+
+  return ConfigureCrtc(
+      x11_output.crtc(), mode_id, x11_output.output(), origin.x(), origin.y());
+}
+
+bool NativeDisplayDelegateX11::ConfigureCrtc(RRCrtc crtc,
+                                             RRMode mode,
+                                             RROutput output,
+                                             int x,
+                                             int y) {
   CHECK(screen_) << "Server not grabbed";
   VLOG(1) << "ConfigureCrtc: crtc=" << crtc << " mode=" << mode
           << " output=" << output << " x=" << x << " y=" << y;
   // Xrandr.h is full of lies. XRRSetCrtcConfig() is defined as returning a
   // Status, which is typically 0 for failure and 1 for success. In
   // actuality it returns a RRCONFIGSTATUS, which uses 0 for success.
-  return XRRSetCrtcConfig(display_,
-                          screen_,
-                          crtc,
-                          CurrentTime,
-                          x,
-                          y,
-                          mode,
-                          RR_Rotate_0,
-                          (output && mode) ? &output : NULL,
-                          (output && mode) ? 1 : 0) == RRSetConfigSuccess;
-}
-
-void NativeDisplayDelegateX11::CreateFrameBuffer(
-    int width,
-    int height,
-    const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
+  if (XRRSetCrtcConfig(display_,
+                       screen_,
+                       crtc,
+                       CurrentTime,
+                       x,
+                       y,
+                       mode,
+                       RR_Rotate_0,
+                       (output && mode) ? &output : NULL,
+                       (output && mode) ? 1 : 0) != RRSetConfigSuccess) {
+    LOG(WARNING) << "Unable to configure CRTC " << crtc << ":"
+                 << " mode=" << mode << " output=" << output << " x=" << x
+                 << " y=" << y;
+    return false;
+  }
+
+  return true;
+}
+
+void NativeDisplayDelegateX11::CreateFrameBuffer(const gfx::Size& size) {
   CHECK(screen_) << "Server not grabbed";
   int current_width = DisplayWidth(display_, DefaultScreen(display_));
   int current_height = DisplayHeight(display_, DefaultScreen(display_));
-  VLOG(1) << "CreateFrameBuffer: new=" << width << "x" << height
+  VLOG(1) << "CreateFrameBuffer: new=" << size.width() << "x" << size.height()
           << " current=" << current_width << "x" << current_height;
-  if (width == current_width && height == current_height)
+  if (size.width() == current_width && size.height() == current_height)
     return;
 
-  DestroyUnusedCrtcs(outputs);
-  int mm_width = width * kPixelsToMmScale;
-  int mm_height = height * kPixelsToMmScale;
-  XRRSetScreenSize(display_, window_, width, height, mm_width, mm_height);
-}
-
-bool NativeDisplayDelegateX11::InitModeInfo(
-    RRMode mode,
-    OutputConfigurator::ModeInfo* mode_info) {
-  DCHECK(mode_info);
-  CHECK(screen_) << "Server not grabbed";
-  // TODO: Determine if we need to organize modes in a way which provides
-  // better than O(n) lookup time.  In many call sites, for example, the
-  // "next" mode is typically what we are looking for so using this
-  // helper might be too expensive.
+  DestroyUnusedCrtcs();
+  int mm_width = size.width() * kPixelsToMmScale;
+  int mm_height = size.height() * kPixelsToMmScale;
+  XRRSetScreenSize(
+      display_, window_, size.width(), size.height(), mm_width, mm_height);
+}
+
+void NativeDisplayDelegateX11::InitModes() {
+  CHECK(screen_) << "Server not grabbed";
+
+  STLDeleteContainerPairSecondPointers(modes_.begin(), modes_.end());
+  modes_.clear();
+
   for (int i = 0; i < screen_->nmode; ++i) {
-    if (mode == screen_->modes[i].id) {
-      const XRRModeInfo& info = screen_->modes[i];
-      mode_info->width = info.width;
-      mode_info->height = info.height;
-      mode_info->interlaced = info.modeFlags & RR_Interlace;
-      if (info.hTotal && info.vTotal) {
-        mode_info->refresh_rate =
-            static_cast<float>(info.dotClock) /
-            (static_cast<float>(info.hTotal) * static_cast<float>(info.vTotal));
-      } else {
-        mode_info->refresh_rate = 0.0f;
-      }
-      return true;
-    }
-  }
-  return false;
-}
-
-OutputConfigurator::OutputSnapshot NativeDisplayDelegateX11::InitOutputSnapshot(
+    const XRRModeInfo& info = screen_->modes[i];
+    float refresh_rate = 0.0f;
+    if (info.hTotal && info.vTotal) {
+      refresh_rate =
+          static_cast<float>(info.dotClock) /
+          (static_cast<float>(info.hTotal) * static_cast<float>(info.vTotal));
+    }
+
+    modes_.insert(
+        std::make_pair(info.id,
+                       new DisplayModeX11(gfx::Size(info.width, info.height),
+                                          info.modeFlags & RR_Interlace,
+                                          refresh_rate,
+                                          info.id)));
+  }
+}
+
+DisplaySnapshotX11* NativeDisplayDelegateX11::InitDisplaySnapshot(
     RROutput id,
     XRROutputInfo* info,
     RRCrtc* last_used_crtc,
     int index) {
-  OutputConfigurator::OutputSnapshot output;
-  output.output = id;
-  output.width_mm = info->mm_width;
-  output.height_mm = info->mm_height;
-  output.has_display_id = base::GetDisplayId(id, index, &output.display_id);
-  output.index = index;
-  bool is_internal = IsInternalOutput(info);
+  int64_t display_id = 0;
+  bool has_display_id = base::GetDisplayId(id, index, &display_id);
+
+  OutputType type = GetOutputTypeFromName(std::string(info->name));
+  if (type == OUTPUT_TYPE_UNKNOWN)
+    LOG(ERROR) << "Unknown link type: " << info->name;
 
   // Use the index as a valid display ID even if the internal
   // display doesn't have valid EDID because the index
   // will never change.
-  if (!output.has_display_id && is_internal)
-    output.has_display_id = true;
-
+  if (!has_display_id) {
+    if (type == OUTPUT_TYPE_INTERNAL)
+      has_display_id = true;
+
+    // Fallback to output index.
+    display_id = index;
+  }
+
+  RRMode native_mode_id = GetOutputNativeMode(info);
+  RRMode current_mode_id = None;
+  gfx::Point origin;
   if (info->crtc) {
     XRRCrtcInfo* crtc_info = XRRGetCrtcInfo(display_, screen_, info->crtc);
-    output.current_mode = crtc_info->mode;
-    output.x = crtc_info->x;
-    output.y = crtc_info->y;
+    current_mode_id = crtc_info->mode;
+    origin.SetPoint(crtc_info->x, crtc_info->y);
     XRRFreeCrtcInfo(crtc_info);
   }
 
+  RRCrtc crtc = None;
   // Assign a CRTC that isn't already in use.
   for (int i = 0; i < info->ncrtc; ++i) {
     if (info->crtcs[i] != *last_used_crtc) {
-      output.crtc = info->crtcs[i];
-      *last_used_crtc = output.crtc;
+      crtc = info->crtcs[i];
+      *last_used_crtc = crtc;
       break;
     }
   }
 
-  output.native_mode = GetOutputNativeMode(info);
-  output.is_aspect_preserving_scaling = IsOutputAspectPreservingScaling(id);
-  output.touch_device_id = None;
-
+  const DisplayMode* current_mode = NULL;
+  const DisplayMode* native_mode = NULL;
+  std::vector<const DisplayMode*> modes;
   for (int i = 0; i < info->nmode; ++i) {
     const RRMode mode = info->modes[i];
-    OutputConfigurator::ModeInfo mode_info;
-    if (InitModeInfo(mode, &mode_info))
-      output.mode_infos.insert(std::make_pair(mode, mode_info));
-    else
+    if (modes_.find(mode) != modes_.end()) {
+      modes.push_back(modes.at(mode));
+
+      if (mode == current_mode_id)
+        current_mode = modes.back();
+      if (mode == native_mode_id)
+        native_mode = modes.back();
+    } else {
       LOG(WARNING) << "Unable to find XRRModeInfo for mode " << mode;
-  }
-
-  std::string name(info->name);
-  if (is_internal) {
-    output.type = ui::OUTPUT_TYPE_INTERNAL;
-  } else if (name.find(kOutputName_VGA) == 0) {
-    output.type = ui::OUTPUT_TYPE_VGA;
-  } else if (name.find(kOutputName_HDMI) == 0) {
-    output.type = ui::OUTPUT_TYPE_HDMI;
-  } else if (name.find(kOutputName_DVI) == 0) {
-    output.type = ui::OUTPUT_TYPE_DVI;
-  } else if (name.find(kOutputName_DisplayPort) == 0) {
-    output.type = ui::OUTPUT_TYPE_DISPLAYPORT;
-  } else {
-    LOG(ERROR) << "Unknown link type: " << name;
-    output.type = ui::OUTPUT_TYPE_UNKNOWN;
-  }
+    }
+  }
+
+  DisplaySnapshotX11* output =
+      new DisplaySnapshotX11(display_id,
+                             has_display_id,
+                             origin,
+                             gfx::Size(info->mm_width, info->mm_height),
+                             type,
+                             IsOutputAspectPreservingScaling(id),
+                             modes,
+                             current_mode,
+                             native_mode,
+                             id,
+                             crtc,
+                             index);
+
+  VLOG(2) << "Found display " << cached_outputs_.size() << ":"
+          << " output=" << output << " crtc=" << crtc
+          << " current_mode=" << current_mode_id;
 
   return output;
 }
 
-bool NativeDisplayDelegateX11::GetHDCPState(
-    const OutputConfigurator::OutputSnapshot& output, ui::HDCPState* state) {
+bool NativeDisplayDelegateX11::GetHDCPState(const DisplaySnapshot& output,
+                                            HDCPState* state) {
   unsigned char* values = NULL;
   int actual_format = 0;
   unsigned long nitems = 0;
   unsigned long bytes_after = 0;
   Atom actual_type = None;
   int success = 0;
+  RROutput output_id = static_cast<const DisplaySnapshotX11&>(output).output();
   // TODO(kcwu): Use X11AtomCache to save round trip time of XInternAtom.
   Atom prop = XInternAtom(display_, kContentProtectionAtomName, False);
 
   bool ok = true;
   // TODO(kcwu): Move this to x11_util (similar method calls in this file and
   // output_util.cc)
   success = XRRGetOutputProperty(display_,
-                                 output.output,
+                                 output_id,
                                  prop,
                                  0,
                                  100,
                                  False,
                                  False,
                                  AnyPropertyType,
                                  &actual_type,
                                  &actual_format,
                                  &nitems,
                                  &bytes_after,
                                  &values);
   if (actual_type == None) {
     LOG(ERROR) << "Property '" << kContentProtectionAtomName
                << "' does not exist";
     ok = false;
   } else if (success == Success && actual_type == XA_ATOM &&
              actual_format == 32 && nitems == 1) {
     Atom value = reinterpret_cast<Atom*>(values)[0];
     if (value == XInternAtom(display_, kProtectionUndesiredAtomName, False)) {
-      *state = ui::HDCP_STATE_UNDESIRED;
+      *state = HDCP_STATE_UNDESIRED;
     } else if (value ==
                XInternAtom(display_, kProtectionDesiredAtomName, False)) {
-      *state = ui::HDCP_STATE_DESIRED;
+      *state = HDCP_STATE_DESIRED;
     } else if (value ==
                XInternAtom(display_, kProtectionEnabledAtomName, False)) {
-      *state = ui::HDCP_STATE_ENABLED;
+      *state = HDCP_STATE_ENABLED;
     } else {
       LOG(ERROR) << "Unknown " << kContentProtectionAtomName
                  << " value: " << value;
       ok = false;
     }
   } else {
     LOG(ERROR) << "XRRGetOutputProperty failed";
     ok = false;
   }
   if (values)
     XFree(values);
 
   VLOG(3) << "HDCP state: " << ok << "," << *state;
   return ok;
 }
 
-bool NativeDisplayDelegateX11::SetHDCPState(
-    const OutputConfigurator::OutputSnapshot& output, ui::HDCPState state) {
+bool NativeDisplayDelegateX11::SetHDCPState(const DisplaySnapshot& output,
+                                            HDCPState state) {
   Atom name = XInternAtom(display_, kContentProtectionAtomName, False);
   Atom value = None;
   switch (state) {
-    case ui::HDCP_STATE_UNDESIRED:
+    case HDCP_STATE_UNDESIRED:
       value = XInternAtom(display_, kProtectionUndesiredAtomName, False);
       break;
-    case ui::HDCP_STATE_DESIRED:
+    case HDCP_STATE_DESIRED:
       value = XInternAtom(display_, kProtectionDesiredAtomName, False);
       break;
     default:
       NOTREACHED() << "Invalid HDCP state: " << state;
       return false;
   }
   base::X11ErrorTracker err_tracker;
   unsigned char* data = reinterpret_cast<unsigned char*>(&value);
+  RROutput output_id = static_cast<const DisplaySnapshotX11&>(output).output();
   XRRChangeOutputProperty(
-      display_, output.output, name, XA_ATOM, 32, PropModeReplace, data, 1);
+      display_, output_id, name, XA_ATOM, 32, PropModeReplace, data, 1);
   if (err_tracker.FoundNewError()) {
     LOG(ERROR) << "XRRChangeOutputProperty failed";
     return false;
   } else {
     return true;
   }
 }
 
-void NativeDisplayDelegateX11::DestroyUnusedCrtcs(
-    const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
+void NativeDisplayDelegateX11::DestroyUnusedCrtcs() {
   CHECK(screen_) << "Server not grabbed";
   // Setting the screen size will fail if any CRTC doesn't fit afterwards.
   // At the same time, turning CRTCs off and back on uses up a lot of time.
   // This function tries to be smart to avoid too many off/on cycles:
   // - We disable all the CRTCs we won't need after the FB resize.
   // - We set the new modes on CRTCs, if they fit in both the old and new
   //   FBs, and park them at (0,0)
   // - We disable the CRTCs we will need but don't fit in the old FB. Those
   //   will be reenabled after the resize.
   // We don't worry about the cached state of the outputs here since we are
   // not interested in the state we are setting - we just try to get the CRTCs
   // out of the way so we can rebuild the frame buffer.
   for (int i = 0; i < screen_->ncrtc; ++i) {
     // Default config is to disable the crtcs.
     RRCrtc crtc = screen_->crtcs[i];
     RRMode mode = None;
     RROutput output = None;
-    const OutputConfigurator::ModeInfo* mode_info = NULL;
-    for (std::vector<OutputConfigurator::OutputSnapshot>::const_iterator it =
-             outputs.begin();
-         it != outputs.end();
+    const DisplayMode* mode_info = NULL;
+    for (ScopedVector<DisplaySnapshot>::const_iterator it =
+             cached_outputs_.begin();
+         it != cached_outputs_.end();
          ++it) {
-      if (crtc == it->crtc) {
-        mode = it->current_mode;
-        output = it->output;
-        if (mode != None)
-          mode_info = OutputConfigurator::GetModeInfo(*it, mode);
+      DisplaySnapshotX11* x11_output = static_cast<DisplaySnapshotX11*>(*it);
+      if (crtc == x11_output->crtc()) {
+        mode_info = x11_output->current_mode();
+        output = x11_output->output();
         break;
       }
     }
 
     if (mode_info) {
+      mode = static_cast<const DisplayModeX11*>(mode_info)->mode_id();
       // In case our CRTC doesn't fit in our current framebuffer, disable it.
       // It'll get reenabled after we resize the framebuffer.
       int current_width = DisplayWidth(display_, DefaultScreen(display_));
       int current_height = DisplayHeight(display_, DefaultScreen(display_));
-      if (mode_info->width > current_width ||
-          mode_info->height > current_height) {
+      if (mode_info->size().width() > current_width ||
+          mode_info->size().height() > current_height) {
         mode = None;
         output = None;
         mode_info = NULL;
       }
     }
 
     ConfigureCrtc(crtc, mode, output, 0, 0);
   }
 }
 
@@ skipping 47 matching lines @@
 }
 
 void NativeDisplayDelegateX11::AddObserver(NativeDisplayObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void NativeDisplayDelegateX11::RemoveObserver(NativeDisplayObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-}  // namespace chromeos
+}  // namespace ui