src/ash/display/display_change_observer_chromeos.cc

   1 // Copyright 2013 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 "ash/display/display_change_observer_chromeos.h"
   6
   7 #include <algorithm>
   8 #include <map>
   9 #include <set>
  10 #include <vector>
  11
  12 #include "ash/ash_switches.h"
  13 #include "ash/display/display_info.h"
  14 #include "ash/display/display_layout_store.h"
  15 #include "ash/display/display_manager.h"
  16 #include "ash/shell.h"
  17 #include "base/command_line.h"
  18 #include "base/logging.h"
  19 #include "chromeos/display/output_util.h"
  20 #include "grit/ash_strings.h"
  21 #include "ui/base/l10n/l10n_util.h"
  22 #include "ui/compositor/dip_util.h"
  23 #include "ui/gfx/display.h"
  24
  25 namespace ash {
  26 namespace internal {
  27
  28 using chromeos::OutputConfigurator;
  29
  30 namespace {
  31
  32 // The DPI threshold to detect high density screen.
  33 // Higher DPI than this will use device_scale_factor=2.
  34 const unsigned int kHighDensityDPIThreshold = 160;
  35
  36 // 1 inch in mm.
  37 const float kInchInMm = 25.4f;
  38
  39 // A list of bogus sizes in mm that X detects that should be ignored.
  40 // See crbug.com/136533. The first element maintains the minimum
  41 // size required to be valid size.
  42 const unsigned long kInvalidDisplaySizeList[][2] = {
  43   {40, 30},
  44   {50, 40},
  45   {160, 90},
  46   {160, 100},
  47 };
  48
  49 // Resolution list are sorted by the area in pixels and the larger
  50 // one comes first.
  51 struct ResolutionSorter {
  52   bool operator()(const Resolution& a, const Resolution& b) {
  53     return a.size.width() * a.size.height() > b.size.width() * b.size.height();
  54   }
  55 };
  56
  57 }  // namespace
  58
  59 // static
  60 bool DisplayChangeObserver::ShouldIgnoreSize(unsigned long mm_width,
  61                                              unsigned long mm_height) {
  62   // Ignore if the reported display is smaller than minimum size.
  63   if (mm_width <= kInvalidDisplaySizeList[0][0] ||
  64       mm_height <= kInvalidDisplaySizeList[0][1]) {
  65     LOG(WARNING) << "Smaller than minimum display size";
  66     return true;
  67   }
  68   for (unsigned long i = 1 ; i < arraysize(kInvalidDisplaySizeList); ++i) {
  69     const unsigned long* size = kInvalidDisplaySizeList[i];
  70     if (mm_width == size[0] && mm_height == size[1]) {
  71       LOG(WARNING) << "Black listed display size detected:"
  72                    << size[0] << "x" << size[1];
  73       return true;
  74     }
  75   }
  76   return false;
  77 }
  78
  79 // static
  80 std::vector<Resolution> DisplayChangeObserver::GetResolutionList(
  81     const OutputConfigurator::OutputSnapshot& output) {
  82   typedef std::map<std::pair<int,int>, Resolution> ResolutionMap;
  83   ResolutionMap resolution_map;
  84
  85   for (std::map<RRMode, OutputConfigurator::ModeInfo>::const_iterator it =
  86        output.mode_infos.begin(); it != output.mode_infos.end(); ++it) {
  87     const OutputConfigurator::ModeInfo& mode_info = it->second;
  88     const std::pair<int, int> size(mode_info.width, mode_info.height);
  89     const Resolution resolution(gfx::Size(mode_info.width, mode_info.height),
  90                                 mode_info.interlaced);
  91
  92     // Add the resolution if it isn't already present and override interlaced
  93     // resolutions with non-interlaced ones.
  94     ResolutionMap::iterator resolution_it = resolution_map.find(size);
  95     if (resolution_it == resolution_map.end())
  96       resolution_map.insert(std::make_pair(size, resolution));
  97     else if (resolution_it->second.interlaced && !resolution.interlaced)
  98       resolution_it->second = resolution;
  99   }
 100
 101   std::vector<Resolution> resolution_list;
 102   for (ResolutionMap::const_iterator iter = resolution_map.begin();
 103        iter != resolution_map.end();
 104        ++iter) {
 105     resolution_list.push_back(iter->second);
 106   }
 107   std::sort(resolution_list.begin(), resolution_list.end(), ResolutionSorter());
 108   return resolution_list;
 109 }
 110
 111 DisplayChangeObserver::DisplayChangeObserver() {
 112   Shell::GetInstance()->AddShellObserver(this);
 113 }
 114
 115 DisplayChangeObserver::~DisplayChangeObserver() {
 116   Shell::GetInstance()->RemoveShellObserver(this);
 117 }
 118
 119 chromeos::OutputState DisplayChangeObserver::GetStateForDisplayIds(
 120     const std::vector<int64>& display_ids) const {
 121   if (CommandLine::ForCurrentProcess()->HasSwitch(
 122           switches::kAshForceMirrorMode)) {
 123     return chromeos::STATE_DUAL_MIRROR;
 124   }
 125
 126   CHECK_EQ(2U, display_ids.size());
 127   DisplayIdPair pair = std::make_pair(display_ids[0], display_ids[1]);
 128   DisplayLayout layout = Shell::GetInstance()->display_manager()->
 129       layout_store()->GetRegisteredDisplayLayout(pair);
 130   return layout.mirrored ?
 131       chromeos::STATE_DUAL_MIRROR : chromeos::STATE_DUAL_EXTENDED;
 132 }
 133
 134 bool DisplayChangeObserver::GetResolutionForDisplayId(int64 display_id,
 135                                                       int* width,
 136                                                       int* height) const {
 137   gfx::Size resolution;
 138   if (!Shell::GetInstance()->display_manager()->
 139       GetSelectedResolutionForDisplayId(display_id, &resolution)) {
 140     return false;
 141   }
 142
 143   *width = resolution.width();
 144   *height = resolution.height();
 145   return true;
 146 }
 147
 148 void DisplayChangeObserver::OnDisplayModeChanged(
 149     const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
 150   std::vector<DisplayInfo> displays;
 151   std::set<int64> ids;
 152   for (size_t i = 0; i < outputs.size(); ++i) {
 153     const OutputConfigurator::OutputSnapshot& output = outputs[i];
 154
 155     if (output.is_internal &&
 156         gfx::Display::InternalDisplayId() == gfx::Display::kInvalidDisplayID) {
 157       // Fall back to output index. crbug.com/180100
 158       gfx::Display::SetInternalDisplayId(
 159           output.display_id == gfx::Display::kInvalidDisplayID ? output.index :
 160           output.display_id);
 161     }
 162
 163     const OutputConfigurator::ModeInfo* mode_info =
 164         OutputConfigurator::GetModeInfo(output, output.current_mode);
 165     if (!mode_info)
 166       continue;
 167
 168     float device_scale_factor = 1.0f;
 169     if (!ShouldIgnoreSize(output.width_mm, output.height_mm) &&
 170         (kInchInMm * mode_info->width / output.width_mm) >
 171         kHighDensityDPIThreshold) {
 172       device_scale_factor = 2.0f;
 173     }
 174     gfx::Rect display_bounds(
 175         output.x, output.y, mode_info->width, mode_info->height);
 176
 177     std::vector<Resolution> resolutions;
 178     if (!output.is_internal)
 179       resolutions = GetResolutionList(output);
 180
 181     std::string name = output.is_internal ?
 182         l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME) :
 183         chromeos::GetDisplayName(output.output);
 184     if (name.empty())
 185       name = l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
 186
 187     bool has_overscan = false;
 188     chromeos::GetOutputOverscanFlag(output.output, &has_overscan);
 189
 190     int64 id = output.display_id;
 191     if (id == gfx::Display::kInvalidDisplayID || ids.find(id) != ids.end())
 192       id = output.index;
 193     ids.insert(id);
 194
 195     displays.push_back(DisplayInfo(id, name, has_overscan));
 196     displays.back().set_device_scale_factor(device_scale_factor);
 197     displays.back().SetBounds(display_bounds);
 198     displays.back().set_native(true);
 199     displays.back().set_resolutions(resolutions);
 200     displays.back().set_touch_support(
 201         output.touch_device_id == 0 ? gfx::Display::TOUCH_SUPPORT_UNAVAILABLE :
 202                                       gfx::Display::TOUCH_SUPPORT_AVAILABLE);
 203   }
 204
 205   // DisplayManager can be null during the boot.
 206   Shell::GetInstance()->display_manager()->OnNativeDisplaysChanged(displays);
 207 }
 208
 209 void DisplayChangeObserver::OnAppTerminating() {
 210 #if defined(USE_ASH)
 211   // Stop handling display configuration events once the shutdown
 212   // process starts. crbug.com/177014.
 213   Shell::GetInstance()->output_configurator()->Stop();
 214 #endif
 215 }
 216
 217 }  // namespace internal
 218 }  // namespace ash