display_change_observer_chromeos.cc revision 6e8cce623b6e4fe0c9e4af605d675dd9d0338c38 
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 "grit/ash_strings.h"
20#include "ui/base/l10n/l10n_util.h"
21#include "ui/compositor/dip_util.h"
22#include "ui/display/types/chromeos/display_mode.h"
23#include "ui/display/types/chromeos/display_snapshot.h"
24#include "ui/display/util/display_util.h"
25#include "ui/gfx/display.h"
26
27namespace ash {
28
29using ui::DisplayConfigurator;
30
31namespace {
32
33// The DPI threshold to determine the device scale factor.
34// DPI higher than |dpi| will use |device_scale_factor|.
35struct DeviceScaleFactorDPIThreshold {
36  float dpi;
37  float device_scale_factor;
38};
39
40const DeviceScaleFactorDPIThreshold kThresholdTable[] = {
41  {180.0f, 2.0f},
42  {150.0f, 1.25f},
43  {0.0f, 1.0f},
44};
45
46// 1 inch in mm.
47const float kInchInMm = 25.4f;
48
49// The minimum pixel width whose monitor can be called as '4K'.
50const int kMinimumWidthFor4K = 3840;
51
52// The list of device scale factors (in addition to 1.0f) which is
53// available in extrenal large monitors.
54const float kAdditionalDeviceScaleFactorsFor4k[] = {1.25f, 2.0f};
55
56// Display mode list is sorted by:
57//  * the area in pixels in ascending order
58//  * refresh rate in descending order
59struct DisplayModeSorter {
60  bool operator()(const DisplayMode& a, const DisplayMode& b) {
61    gfx::Size size_a_dip = a.GetSizeInDIP();
62    gfx::Size size_b_dip = b.GetSizeInDIP();
63    if (size_a_dip.GetArea() == size_b_dip.GetArea())
64      return (a.refresh_rate > b.refresh_rate);
65    return (size_a_dip.GetArea() < size_b_dip.GetArea());
66  }
67};
68
69}  // namespace
70
71// static
72std::vector<DisplayMode> DisplayChangeObserver::GetInternalDisplayModeList(
73    const DisplayInfo& display_info,
74    const DisplayConfigurator::DisplayState& output) {
75  std::vector<DisplayMode> display_mode_list;
76  const ui::DisplayMode* ui_native_mode = output.display->native_mode();
77  DisplayMode native_mode(ui_native_mode->size(),
78                          ui_native_mode->refresh_rate(),
79                          ui_native_mode->is_interlaced(),
80                          true);
81  native_mode.device_scale_factor = display_info.device_scale_factor();
82  std::vector<float> ui_scales =
83      DisplayManager::GetScalesForDisplay(display_info);
84  for (size_t i = 0; i < ui_scales.size(); ++i) {
85    DisplayMode mode = native_mode;
86    mode.ui_scale = ui_scales[i];
87    mode.native = (ui_scales[i] == 1.0f);
88    display_mode_list.push_back(mode);
89  }
90
91  std::sort(
92      display_mode_list.begin(), display_mode_list.end(), DisplayModeSorter());
93  return display_mode_list;
94}
95
96// static
97std::vector<DisplayMode> DisplayChangeObserver::GetExternalDisplayModeList(
98    const DisplayConfigurator::DisplayState& output) {
99  typedef std::map<std::pair<int, int>, DisplayMode> DisplayModeMap;
100  DisplayModeMap display_mode_map;
101
102  DisplayMode native_mode;
103  for (std::vector<const ui::DisplayMode*>::const_iterator it =
104           output.display->modes().begin();
105       it != output.display->modes().end();
106       ++it) {
107    const ui::DisplayMode& mode_info = **it;
108    const std::pair<int, int> size(mode_info.size().width(),
109                                   mode_info.size().height());
110    const DisplayMode display_mode(mode_info.size(),
111                                   mode_info.refresh_rate(),
112                                   mode_info.is_interlaced(),
113                                   output.display->native_mode() == *it);
114    if (display_mode.native)
115      native_mode = display_mode;
116
117    // Add the display mode if it isn't already present and override interlaced
118    // display modes with non-interlaced ones.
119    DisplayModeMap::iterator display_mode_it = display_mode_map.find(size);
120    if (display_mode_it == display_mode_map.end())
121      display_mode_map.insert(std::make_pair(size, display_mode));
122    else if (display_mode_it->second.interlaced && !display_mode.interlaced)
123      display_mode_it->second = display_mode;
124  }
125
126  std::vector<DisplayMode> display_mode_list;
127  for (DisplayModeMap::const_iterator iter = display_mode_map.begin();
128       iter != display_mode_map.end();
129       ++iter) {
130    display_mode_list.push_back(iter->second);
131  }
132
133  if (native_mode.size.width() >= kMinimumWidthFor4K) {
134    for (size_t i = 0; i < arraysize(kAdditionalDeviceScaleFactorsFor4k);
135         ++i) {
136      DisplayMode mode = native_mode;
137      mode.device_scale_factor = kAdditionalDeviceScaleFactorsFor4k[i];
138      mode.native = false;
139      display_mode_list.push_back(mode);
140    }
141  }
142
143  std::sort(
144      display_mode_list.begin(), display_mode_list.end(), DisplayModeSorter());
145  return display_mode_list;
146}
147
148DisplayChangeObserver::DisplayChangeObserver() {
149  Shell::GetInstance()->AddShellObserver(this);
150}
151
152DisplayChangeObserver::~DisplayChangeObserver() {
153  Shell::GetInstance()->RemoveShellObserver(this);
154}
155
156ui::MultipleDisplayState DisplayChangeObserver::GetStateForDisplayIds(
157    const std::vector<int64>& display_ids) const {
158  CHECK_EQ(2U, display_ids.size());
159  DisplayIdPair pair = std::make_pair(display_ids[0], display_ids[1]);
160  DisplayLayout layout = Shell::GetInstance()->display_manager()->
161      layout_store()->GetRegisteredDisplayLayout(pair);
162  return layout.mirrored ? ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR :
163                           ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED;
164}
165
166bool DisplayChangeObserver::GetResolutionForDisplayId(int64 display_id,
167                                                      gfx::Size* size) const {
168  DisplayMode mode;
169  if (!Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
170           display_id, &mode))
171    return false;
172
173  *size = mode.size;
174  return true;
175}
176
177void DisplayChangeObserver::OnDisplayModeChanged(
178    const std::vector<DisplayConfigurator::DisplayState>& display_states) {
179  std::vector<DisplayInfo> displays;
180  std::set<int64> ids;
181  for (size_t i = 0; i < display_states.size(); ++i) {
182    const DisplayConfigurator::DisplayState& state = display_states[i];
183
184    if (state.display->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL &&
185        gfx::Display::InternalDisplayId() == gfx::Display::kInvalidDisplayID) {
186      gfx::Display::SetInternalDisplayId(state.display->display_id());
187    }
188
189    const ui::DisplayMode* mode_info = state.display->current_mode();
190    if (!mode_info)
191      continue;
192
193    float device_scale_factor = 1.0f;
194    if (state.display->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) {
195      if (!ui::IsDisplaySizeBlackListed(state.display->physical_size())) {
196        device_scale_factor =
197            FindDeviceScaleFactor((kInchInMm * mode_info->size().width() /
198                                   state.display->physical_size().width()));
199      }
200    } else {
201      DisplayMode mode;
202      if (Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
203              state.display->display_id(), &mode)) {
204        device_scale_factor = mode.device_scale_factor;
205      }
206    }
207    gfx::Rect display_bounds(state.display->origin(), mode_info->size());
208
209    std::string name =
210        state.display->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL ?
211            l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME) :
212            state.display->display_name();
213    if (name.empty())
214      name = l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
215
216    bool has_overscan = state.display->has_overscan();
217    int64 id = state.display->display_id();
218    ids.insert(id);
219
220    displays.push_back(DisplayInfo(id, name, has_overscan));
221    DisplayInfo& new_info = displays.back();
222    new_info.set_device_scale_factor(device_scale_factor);
223    new_info.SetBounds(display_bounds);
224    new_info.set_native(true);
225    new_info.set_touch_support(state.touch_device_id == 0 ?
226        gfx::Display::TOUCH_SUPPORT_UNAVAILABLE :
227        gfx::Display::TOUCH_SUPPORT_AVAILABLE);
228    new_info.set_touch_device_id(state.touch_device_id);
229    new_info.set_is_aspect_preserving_scaling(
230        state.display->is_aspect_preserving_scaling());
231
232    std::vector<DisplayMode> display_modes =
233        (state.display->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) ?
234        GetInternalDisplayModeList(new_info, state) :
235        GetExternalDisplayModeList(state);
236    new_info.set_display_modes(display_modes);
237
238    new_info.set_available_color_profiles(
239        Shell::GetInstance()
240            ->display_configurator()
241            ->GetAvailableColorCalibrationProfiles(id));
242  }
243
244  // DisplayManager can be null during the boot.
245  Shell::GetInstance()->display_manager()->OnNativeDisplaysChanged(displays);
246}
247
248void DisplayChangeObserver::OnAppTerminating() {
249#if defined(USE_ASH)
250  // Stop handling display configuration events once the shutdown
251  // process starts. crbug.com/177014.
252  Shell::GetInstance()->display_configurator()->PrepareForExit();
253#endif
254}
255
256// static
257float DisplayChangeObserver::FindDeviceScaleFactor(float dpi) {
258  for (size_t i = 0; i < arraysize(kThresholdTable); ++i) {
259    if (dpi > kThresholdTable[i].dpi)
260      return kThresholdTable[i].device_scale_factor;
261  }
262  return 1.0f;
263}
264
265}  // namespace ash
266