ash: Get output info from chromeos instead of XRandR.

ash/display/display_change_observer_chromeos.cc

Index: ash/display/display_change_observer_chromeos.cc
diff --git a/ash/display/display_change_observer_chromeos.cc b/ash/display/display_change_observer_chromeos.cc
new file mode 100644
index 0000000000000000000000000000000000000000..be70b38adf608f8a265579e6af27d20dcf32f282
--- /dev/null
+++ b/ash/display/display_change_observer_chromeos.cc
@@ -0,0 +1,215 @@
+// Copyright (c) 2012 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.

[oshima, 2013/08/19 20:00:24]

can you adjust similarity so that we can keep history?

[Daniel Erat, 2013/08/19 22:09:30]

Sure, I'll give this a try.

+
+#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 "chromeos/display/output_util.h"
+#include "grit/ash_strings.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/compositor/dip_util.h"
+#include "ui/gfx/display.h"
+
+namespace ash {
+namespace internal {
+
+using chromeos::OutputConfigurator;
+
+namespace {
+
+// The DPI threshold to detect high density screen.
+// Higher DPI than this will use device_scale_factor=2.
+const unsigned int kHighDensityDPIThreshold = 160;
+
+// 1 inch in mm.
+const float kInchInMm = 25.4f;
+
+// A list of bogus sizes in mm that X detects that should be ignored.
+// See crbug.com/136533. The first element maintains the minimum
+// size required to be valid size.
+const unsigned long kInvalidDisplaySizeList[][2] = {
+  {40, 30},
+  {50, 40},
+  {160, 90},
+  {160, 100},
+};
+
+// Resolution list are sorted by the area in pixels and the larger
+// one comes first.
+struct ResolutionSorter {
+  bool operator()(const Resolution& a, const Resolution& b) {
+    return a.size.width() * a.size.height() > b.size.width() * b.size.height();
+  }
+};
+
+}  // namespace
+
+// static
+bool DisplayChangeObserver::ShouldIgnoreSize(unsigned long mm_width,
+                                             unsigned long mm_height) {
+  // Ignore if the reported display is smaller than minimum size.
+  if (mm_width <= kInvalidDisplaySizeList[0][0] ||
+      mm_height <= kInvalidDisplaySizeList[0][1]) {
+    LOG(WARNING) << "Smaller than minimum display size";
+    return true;
+  }
+  for (unsigned long i = 1 ; i < arraysize(kInvalidDisplaySizeList); ++i) {
+    const unsigned long* size = kInvalidDisplaySizeList[i];
+    if (mm_width == size[0] && mm_height == size[1]) {
+      LOG(WARNING) << "Black listed display size detected:"
+                   << size[0] << "x" << size[1];
+      return true;
+    }
+  }
+  return false;
+}
+
+// static
+std::vector<Resolution> DisplayChangeObserver::GetResolutionList(
+    const OutputConfigurator::OutputSnapshot& output) {
+  typedef std::map<std::pair<int,int>, Resolution> ResolutionMap;
+  ResolutionMap resolution_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 Resolution resolution(gfx::Size(mode_info.width, mode_info.height),
+                                mode_info.interlaced);
+
+    // Add the resolution if it isn't already present and override interlaced
+    // resolutions with non-interlaced ones.
+    ResolutionMap::iterator resolution_it = resolution_map.find(size);
+    if (resolution_it == resolution_map.end())
+      resolution_map.insert(std::make_pair(size, resolution));
+    else if (resolution_it->second.interlaced && !resolution.interlaced)
+      resolution_it->second = resolution;
+  }
+
+  std::vector<Resolution> resolution_list;
+  for (ResolutionMap::const_iterator iter = resolution_map.begin();
+       iter != resolution_map.end();
+       ++iter) {
+    resolution_list.push_back(iter->second);
+  }
+  std::sort(resolution_list.begin(), resolution_list.end(), ResolutionSorter());
+  return resolution_list;
+}
+
+DisplayChangeObserver::DisplayChangeObserver() {
+  Shell::GetInstance()->AddShellObserver(this);
+}
+
+DisplayChangeObserver::~DisplayChangeObserver() {
+  Shell::GetInstance()->RemoveShellObserver(this);
+}
+
+chromeos::OutputState DisplayChangeObserver::GetStateForDisplayIds(
+    const std::vector<int64>& display_ids) const {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAshForceMirrorMode)) {
+    return chromeos::STATE_DUAL_MIRROR;
+  }
+
+  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 ?
+      chromeos::STATE_DUAL_MIRROR : chromeos::STATE_DUAL_EXTENDED;
+}
+
+bool DisplayChangeObserver::GetResolutionForDisplayId(int64 display_id,
+                                                      int* width,
+                                                      int* height) const {
+  gfx::Size resolution;
+  if (!Shell::GetInstance()->display_manager()->
+      GetSelectedResolutionForDisplayId(display_id, &resolution)) {
+    return false;
+  }
+
+  *width = resolution.width();
+  *height = resolution.height();
+  return true;
+}
+
+void DisplayChangeObserver::OnDisplayModeChanged(
+    const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
+  std::vector<DisplayInfo> displays;
+  std::set<int64> ids;
+  for (size_t output_index = 0; output_index < outputs.size(); ++output_index) {
+    const OutputConfigurator::OutputSnapshot& output = outputs[output_index];
+
+    if (output.is_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);
+    }
+
+    const OutputConfigurator::ModeInfo* mode_info =
+        OutputConfigurator::GetModeInfo(output, output.current_mode);
+    if (!mode_info)
+      continue;
+
+    float device_scale_factor = 1.0f;
+    if (!ShouldIgnoreSize(output.width_mm, output.height_mm) &&
+        (kInchInMm * mode_info->width / output.width_mm) >
+        kHighDensityDPIThreshold) {
+      device_scale_factor = 2.0f;
+    }
+    gfx::Rect display_bounds(
+        output.x, output.y, mode_info->width, mode_info->height);
+
+    std::vector<Resolution> resolutions;
+    if (!output.is_internal)
+      resolutions = GetResolutionList(output);
+
+    std::string name = output.is_internal ?
+        l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME) :
+        chromeos::GetDisplayName(output.output);
+    if (name.empty())
+      name = l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
+
+    bool has_overscan = false;
+    chromeos::GetOutputOverscanFlag(output.output, &has_overscan);
+
+    int64 id = output.display_id;
+    if (id == gfx::Display::kInvalidDisplayID || ids.find(id) != ids.end())
+      id = output_index;
+    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_resolutions(resolutions);
+  }
+
+  // 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()->Stop();
+#endif
+}
+
+}  // namespace internal
+}  // namespace ash