Refactoring display configuration state to allow generic state objects

ash/display/display_change_observer_chromeos.cc

 // Copyright 2013 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 "ash/display/display_change_observer_chromeos.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/compositor/dip_util.h"
-#include "ui/display/chromeos/x11/display_util.h"
+#include "ui/display/chromeos/display_mode.h"
+#include "ui/display/chromeos/display_snapshot.h"
 #include "ui/gfx/display.h"
 
 namespace ash {
 namespace internal {
 
 using ui::OutputConfigurator;
 
 namespace {
 
 // The DPI threshold to detect high density screen.
@@ skipping 11 matching lines @@
     if (a.size.GetArea() == b.size.GetArea())
       return (a.refresh_rate > b.refresh_rate);
     return (a.size.GetArea() > b.size.GetArea());
   }
 };
 
 }  // namespace
 
 // static
 std::vector<DisplayMode> DisplayChangeObserver::GetDisplayModeList(
-    const OutputConfigurator::OutputSnapshot& output) {
+    const OutputConfigurator::DisplayState& output) {
   typedef std::map<std::pair<int, int>, DisplayMode> DisplayModeMap;
   DisplayModeMap display_mode_map;
 
-  for (std::map<RRMode, OutputConfigurator::ModeInfo>::const_iterator it =
-       output.mode_infos.begin(); it != output.mode_infos.end(); ++it) {
-    const OutputConfigurator::ModeInfo& mode_info = it->second;
-    const std::pair<int, int> size(mode_info.width, mode_info.height);
-    const DisplayMode display_mode(gfx::Size(mode_info.width, mode_info.height),
-                                   mode_info.refresh_rate,
-                                   mode_info.interlaced,
-                                   output.native_mode == it->first);
+  for (std::vector<const ui::DisplayMode*>::const_iterator it =
+           output.display->modes().begin();
+       it != output.display->modes().end();
+       ++it) {
+    const ui::DisplayMode& mode_info = **it;
+    const std::pair<int, int> size(mode_info.size().width(),
+                                   mode_info.size().height());
+    const DisplayMode display_mode(mode_info.size(),
+                                   mode_info.refresh_rate(),
+                                   mode_info.is_interlaced(),
+                                   output.display->native_mode() == *it);
 
     // Add the display mode if it isn't already present and override interlaced
     // display modes with non-interlaced ones.
     DisplayModeMap::iterator display_mode_it = display_mode_map.find(size);
     if (display_mode_it == display_mode_map.end())
       display_mode_map.insert(std::make_pair(size, display_mode));
     else if (display_mode_it->second.interlaced && !display_mode.interlaced)
       display_mode_it->second = display_mode;
   }
 
@@ skipping 20 matching lines @@
     const std::vector<int64>& display_ids) const {
   CHECK_EQ(2U, display_ids.size());
   DisplayIdPair pair = std::make_pair(display_ids[0], display_ids[1]);
   DisplayLayout layout = Shell::GetInstance()->display_manager()->
       layout_store()->GetRegisteredDisplayLayout(pair);
   return layout.mirrored ? ui::OUTPUT_STATE_DUAL_MIRROR :
                            ui::OUTPUT_STATE_DUAL_EXTENDED;
 }
 
 bool DisplayChangeObserver::GetResolutionForDisplayId(int64 display_id,
-                                                      int* width,
-                                                      int* height) const {
+                                                      gfx::Size* size) const {
   DisplayMode mode;
   if (!Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
            display_id, &mode))
     return false;
 
-  *width = mode.size.width();
-  *height = mode.size.height();
+  *size = mode.size;
   return true;
 }
 
 void DisplayChangeObserver::OnDisplayModeChanged(
-    const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
+    const std::vector<OutputConfigurator::DisplayState>& outputs) {
   std::vector<DisplayInfo> displays;
   std::set<int64> ids;
   for (size_t i = 0; i < outputs.size(); ++i) {
-    const OutputConfigurator::OutputSnapshot& output = outputs[i];
+    const OutputConfigurator::DisplayState& output = outputs[i];
 
-    if (output.type == ui::OUTPUT_TYPE_INTERNAL &&
+    if (output.display->type() == ui::OUTPUT_TYPE_INTERNAL &&
         gfx::Display::InternalDisplayId() == gfx::Display::kInvalidDisplayID) {
-      // Fall back to output index. crbug.com/180100
-      gfx::Display::SetInternalDisplayId(
-          output.display_id == gfx::Display::kInvalidDisplayID ? output.index :
-          output.display_id);
+      gfx::Display::SetInternalDisplayId(output.display->display_id());
     }
 
-    const OutputConfigurator::ModeInfo* mode_info =
-        OutputConfigurator::GetModeInfo(output, output.current_mode);
+    const ui::DisplayMode* mode_info = output.display->current_mode();
     if (!mode_info)
       continue;
 
     float device_scale_factor = 1.0f;
-    if (!ui::IsXDisplaySizeBlackListed(output.width_mm, output.height_mm) &&
-        (kInchInMm * mode_info->width / output.width_mm) >
-        kHighDensityDPIThreshold) {
+    if (!ui::IsXDisplaySizeBlackListed(
+            output.display->physical_size().width(),
+            output.display->physical_size().height()) &&
+        (kInchInMm * mode_info->size().width() /
+         output.display->physical_size().width()) > kHighDensityDPIThreshold) {
       device_scale_factor = 2.0f;
     }
-    gfx::Rect display_bounds(
-        output.x, output.y, mode_info->width, mode_info->height);
+    gfx::Rect display_bounds(output.display->origin(), mode_info->size());
 
     std::vector<DisplayMode> display_modes = GetDisplayModeList(output);
 
     std::string name =
-        output.type == ui::OUTPUT_TYPE_INTERNAL
+        output.display->type() == ui::OUTPUT_TYPE_INTERNAL
             ? l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME) :
-              ui::GetDisplayName(output);
+              output.display->GetDisplayName();
     if (name.empty())
       name = l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
 
-    bool has_overscan = false;
-    ui::GetOutputOverscanFlag(output, &has_overscan);
-
-    int64 id = output.display_id;
-    if (id == gfx::Display::kInvalidDisplayID || ids.find(id) != ids.end())
-      id = output.index;
+    bool has_overscan = output.display->GetOverscanFlag();
+    int64 id = output.display->display_id();
     ids.insert(id);
 
     displays.push_back(DisplayInfo(id, name, has_overscan));
     displays.back().set_device_scale_factor(device_scale_factor);
     displays.back().SetBounds(display_bounds);
     displays.back().set_native(true);
     displays.back().set_display_modes(display_modes);
     displays.back().set_touch_support(
         output.touch_device_id == 0 ? gfx::Display::TOUCH_SUPPORT_UNAVAILABLE :
                                       gfx::Display::TOUCH_SUPPORT_AVAILABLE);
   }
 
   // DisplayManager can be null during the boot.
   Shell::GetInstance()->display_manager()->OnNativeDisplaysChanged(displays);
 }
 
 void DisplayChangeObserver::OnAppTerminating() {
 #if defined(USE_ASH)
   // Stop handling display configuration events once the shutdown
   // process starts. crbug.com/177014.
   Shell::GetInstance()->output_configurator()->PrepareForExit();
 #endif
 }
 
 }  // namespace internal
 }  // namespace ash