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