Relocate reuseable portions of ash/display/display_util.*

ash/display/display_util.cc

 // Copyright 2014 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_util.h"
 
 #include <algorithm>
 
 #include "ash/common/new_window_delegate.h"
 #include "ash/common/system/system_notifier.h"
@@ skipping 41 matching lines @@
     WmShell::Get()->new_window_delegate()->OpenFeedbackPage();
   }
 
  private:
   // Private destructor since NotificationDelegate is ref-counted.
   ~DisplayErrorNotificationDelegate() override = default;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayErrorNotificationDelegate);
 };
 
-// List of value UI Scale values. Scales for 2x are equivalent to 640,
-// 800, 1024, 1280, 1440, 1600 and 1920 pixel width respectively on
-// 2560 pixel width 2x density display. Please see crbug.com/233375
-// for the full list of resolutions.
-const float kUIScalesFor2x[] = {0.5f,   0.625f, 0.8f, 1.0f,
-                                1.125f, 1.25f,  1.5f, 2.0f};
-const float kUIScalesFor1_25x[] = {0.5f, 0.625f, 0.8f, 1.0f, 1.25f};
-const float kUIScalesFor1280[] = {0.5f, 0.625f, 0.8f, 1.0f, 1.125f};
-const float kUIScalesFor1366[] = {0.5f, 0.6f, 0.75f, 1.0f, 1.125f};
-
-std::vector<float> GetScalesForDisplay(
-    const scoped_refptr<display::ManagedDisplayMode>& native_mode) {
-#define ASSIGN_ARRAY(v, a) v.assign(a, a + arraysize(a))
-
-  std::vector<float> ret;
-  if (native_mode->device_scale_factor() == 2.0f) {
-    ASSIGN_ARRAY(ret, kUIScalesFor2x);
-    return ret;
-  } else if (native_mode->device_scale_factor() == 1.25f) {
-    ASSIGN_ARRAY(ret, kUIScalesFor1_25x);
-    return ret;
-  }
-  switch (native_mode->size().width()) {
-    case 1280:
-      ASSIGN_ARRAY(ret, kUIScalesFor1280);
-      break;
-    case 1366:
-      ASSIGN_ARRAY(ret, kUIScalesFor1366);
-      break;
-    default:
-      ASSIGN_ARRAY(ret, kUIScalesFor1280);
-#if defined(OS_CHROMEOS)
-      if (base::SysInfo::IsRunningOnChromeOS())
-        NOTREACHED() << "Unknown resolution:" << native_mode->size().ToString();
-#endif
-  }
-  return ret;
-}
-
-struct ScaleComparator {
-  explicit ScaleComparator(float s) : scale(s) {}
-
-  bool operator()(
-      const scoped_refptr<display::ManagedDisplayMode>& mode) const {
-    const float kEpsilon = 0.0001f;
-    return std::abs(scale - mode->ui_scale()) < kEpsilon;
-  }
-  float scale;
-};
 
 void ConvertPointFromScreenToNative(aura::WindowTreeHost* host,
                                     gfx::Point* point) {
   ::wm::ConvertPointFromScreen(host->window(), point);
   host->ConvertPointToNativeScreen(point);
 }
 
 scoped_refptr<display::ManagedDisplayMode> GetDisplayModeForUIScale(
     const display::ManagedDisplayInfo& info,
     float ui_scale) {
   const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
       info.display_modes();
   auto iter = std::find_if(
       modes.begin(), modes.end(),
       [ui_scale](const scoped_refptr<display::ManagedDisplayMode>& mode) {
         return mode->ui_scale() == ui_scale;
       });
   if (iter == modes.end())
     return scoped_refptr<display::ManagedDisplayMode>();
   return *iter;
 }
 
-scoped_refptr<display::ManagedDisplayMode> FindNextMode(
-    const display::ManagedDisplayInfo::ManagedDisplayModeList& modes,
-    size_t index,
-    bool up) {
-  DCHECK_LT(index, modes.size());
-  size_t new_index = index;
-  if (up && (index + 1 < modes.size()))
-    ++new_index;
-  else if (!up && index != 0)
-    --new_index;
-  return modes[new_index];
-}
-
 }  // namespace
 
-display::ManagedDisplayInfo::ManagedDisplayModeList
-CreateInternalManagedDisplayModeList(
-    const scoped_refptr<display::ManagedDisplayMode>& native_mode) {
-  display::ManagedDisplayInfo::ManagedDisplayModeList display_mode_list;
-
-  float native_ui_scale = (native_mode->device_scale_factor() == 1.25f)
-                              ? 1.0f
-                              : native_mode->device_scale_factor();
-  for (float ui_scale : GetScalesForDisplay(native_mode)) {
-    scoped_refptr<display::ManagedDisplayMode> mode(
-        new display::ManagedDisplayMode(
-            native_mode->size(), native_mode->refresh_rate(),
-            native_mode->is_interlaced(), ui_scale == native_ui_scale, ui_scale,
-            native_mode->device_scale_factor()));
-    display_mode_list.push_back(mode);
-  }
-  return display_mode_list;
-}
-
-display::ManagedDisplayInfo::ManagedDisplayModeList
-CreateUnifiedManagedDisplayModeList(
-    const scoped_refptr<display::ManagedDisplayMode>& native_mode,
-    const std::set<std::pair<float, float>>& dsf_scale_list) {
-  display::ManagedDisplayInfo::ManagedDisplayModeList display_mode_list;
-
-  for (auto& pair : dsf_scale_list) {
-    gfx::SizeF scaled_size(native_mode->size());
-    scaled_size.Scale(pair.second);
-    scoped_refptr<display::ManagedDisplayMode> mode(
-        new display::ManagedDisplayMode(
-            gfx::ToFlooredSize(scaled_size), native_mode->refresh_rate(),
-            native_mode->is_interlaced(), false /* native */,
-            native_mode->ui_scale(), pair.first /* device_scale_factor */));
-    display_mode_list.push_back(mode);
-  }
-  // Sort the mode by the size in DIP.
-  std::sort(display_mode_list.begin(), display_mode_list.end(),
-            [](const scoped_refptr<display::ManagedDisplayMode>& a,
-               const scoped_refptr<display::ManagedDisplayMode>& b) {
-              return a->GetSizeInDIP(false).GetArea() <
-                     b->GetSizeInDIP(false).GetArea();
-            });
-  return display_mode_list;
-}
-
-scoped_refptr<display::ManagedDisplayMode> GetDisplayModeForResolution(
-    const display::ManagedDisplayInfo& info,
-    const gfx::Size& resolution) {
-  if (display::Display::IsInternalDisplayId(info.id()))
-    return scoped_refptr<display::ManagedDisplayMode>();
-
-  const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
-      info.display_modes();
-  DCHECK_NE(0u, modes.size());
-  scoped_refptr<display::ManagedDisplayMode> target_mode;
-  display::ManagedDisplayInfo::ManagedDisplayModeList::const_iterator iter =
-      std::find_if(
-          modes.begin(), modes.end(),
-          [resolution](const scoped_refptr<display::ManagedDisplayMode>& mode) {
-            return mode->size() == resolution;
-          });
-  if (iter == modes.end()) {
-    LOG(WARNING) << "Unsupported resolution was requested:"
-                 << resolution.ToString();
-    return scoped_refptr<display::ManagedDisplayMode>();
-  }
-  return *iter;
-}
-
-scoped_refptr<display::ManagedDisplayMode> GetDisplayModeForNextUIScale(
-    const display::ManagedDisplayInfo& info,
-    bool up) {
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  if (!display_manager->IsActiveDisplayId(info.id()) ||
-      !display::Display::IsInternalDisplayId(info.id())) {
-    return scoped_refptr<display::ManagedDisplayMode>();
-  }
-  const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
-      info.display_modes();
-  ScaleComparator comparator(info.configured_ui_scale());
-  auto iter = std::find_if(modes.begin(), modes.end(), comparator);
-  return FindNextMode(modes, iter - modes.begin(), up);
-}
-
-scoped_refptr<display::ManagedDisplayMode> GetDisplayModeForNextResolution(
-    const display::ManagedDisplayInfo& info,
-    bool up) {
-  if (display::Display::IsInternalDisplayId(info.id()))
-    return scoped_refptr<display::ManagedDisplayMode>();
-
-  const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
-      info.display_modes();
-  scoped_refptr<display::ManagedDisplayMode> tmp =
-      new display::ManagedDisplayMode(info.size_in_pixel(), 0.0, false, false,
-                                      1.0, info.device_scale_factor());
-  gfx::Size resolution = tmp->GetSizeInDIP(false);
-
-  auto iter = std::find_if(
-      modes.begin(), modes.end(),
-      [resolution](const scoped_refptr<display::ManagedDisplayMode>& mode) {
-        return mode->GetSizeInDIP(false) == resolution;
-      });
-  return FindNextMode(modes, iter - modes.begin(), up);
-}
-
 bool SetDisplayUIScale(int64_t id, float ui_scale) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->IsActiveDisplayId(id) ||
       !display::Display::IsInternalDisplayId(id)) {
     return false;
   }
   const display::ManagedDisplayInfo& info = display_manager->GetDisplayInfo(id);
 
   scoped_refptr<display::ManagedDisplayMode> mode =
       GetDisplayModeForUIScale(info, ui_scale);
   if (!mode)
     return false;
   return display_manager->SetDisplayMode(id, mode);
 }
 
-bool HasDisplayModeForUIScale(const display::ManagedDisplayInfo& info,
-                              float ui_scale) {
-  ScaleComparator comparator(ui_scale);
-  const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
-      info.display_modes();
-  return std::find_if(modes.begin(), modes.end(), comparator) != modes.end();
-}
-
-bool ComputeBoundary(const display::Display& a_display,
-                     const display::Display& b_display,
-                     gfx::Rect* a_edge_in_screen,
-                     gfx::Rect* b_edge_in_screen) {
-  const gfx::Rect& a_bounds = a_display.bounds();
-  const gfx::Rect& b_bounds = b_display.bounds();
-
-  // Find touching side.
-  int rx = std::max(a_bounds.x(), b_bounds.x());
-  int ry = std::max(a_bounds.y(), b_bounds.y());
-  int rr = std::min(a_bounds.right(), b_bounds.right());
-  int rb = std::min(a_bounds.bottom(), b_bounds.bottom());
-
-  display::DisplayPlacement::Position position;
-  if ((rb - ry) == 0) {
-    // top bottom
-    if (a_bounds.bottom() == b_bounds.y()) {
-      position = display::DisplayPlacement::BOTTOM;
-    } else if (a_bounds.y() == b_bounds.bottom()) {
-      position = display::DisplayPlacement::TOP;
-    } else {
-      return false;
-    }
-  } else {
-    // left right
-    if (a_bounds.right() == b_bounds.x()) {
-      position = display::DisplayPlacement::RIGHT;
-    } else if (a_bounds.x() == b_bounds.right()) {
-      position = display::DisplayPlacement::LEFT;
-    } else {
-      DCHECK_NE(rr, rx);
-      return false;
-    }
-  }
-
-  switch (position) {
-    case display::DisplayPlacement::TOP:
-    case display::DisplayPlacement::BOTTOM: {
-      int left = std::max(a_bounds.x(), b_bounds.x());
-      int right = std::min(a_bounds.right(), b_bounds.right());
-      if (position == display::DisplayPlacement::TOP) {
-        a_edge_in_screen->SetRect(left, a_bounds.y(), right - left, 1);
-        b_edge_in_screen->SetRect(left, b_bounds.bottom() - 1, right - left, 1);
-      } else {
-        a_edge_in_screen->SetRect(left, a_bounds.bottom() - 1, right - left, 1);
-        b_edge_in_screen->SetRect(left, b_bounds.y(), right - left, 1);
-      }
-      break;
-    }
-    case display::DisplayPlacement::LEFT:
-    case display::DisplayPlacement::RIGHT: {
-      int top = std::max(a_bounds.y(), b_bounds.y());
-      int bottom = std::min(a_bounds.bottom(), b_bounds.bottom());
-      if (position == display::DisplayPlacement::LEFT) {
-        a_edge_in_screen->SetRect(a_bounds.x(), top, 1, bottom - top);
-        b_edge_in_screen->SetRect(b_bounds.right() - 1, top, 1, bottom - top);
-      } else {
-        a_edge_in_screen->SetRect(a_bounds.right() - 1, top, 1, bottom - top);
-        b_edge_in_screen->SetRect(b_bounds.x(), top, 1, bottom - top);
-      }
-      break;
-    }
-  }
-  return true;
-}
-
 gfx::Rect GetNativeEdgeBounds(AshWindowTreeHost* ash_host,
                               const gfx::Rect& bounds_in_screen) {
   aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
   gfx::Rect native_bounds = host->GetBounds();
   native_bounds.Inset(ash_host->GetHostInsets());
   gfx::Point start_in_native = bounds_in_screen.origin();
   gfx::Point end_in_native = bounds_in_screen.bottom_right();
 
   ConvertPointFromScreenToNative(host, &start_in_native);
   ConvertPointFromScreenToNative(host, &end_in_native);
@@ skipping 57 matching lines @@
           &new_point_in_screen);
     } else {
       new_point_in_screen = point_in_native;
       host->ConvertPointFromNativeScreen(&new_point_in_screen);
       ::wm::ConvertPointToScreen(host->window(), &new_point_in_screen);
     }
     aura::Env::GetInstance()->set_last_mouse_location(new_point_in_screen);
   }
 }
 
-int FindDisplayIndexContainingPoint(
-    const std::vector<display::Display>& displays,
-    const gfx::Point& point_in_screen) {
-  auto iter = std::find_if(displays.begin(), displays.end(),
-                           [point_in_screen](const display::Display& display) {
-                             return display.bounds().Contains(point_in_screen);
-                           });
-  return iter == displays.end() ? -1 : (iter - displays.begin());
-}
-
-display::DisplayIdList CreateDisplayIdList(const display::DisplayList& list) {
-  return GenerateDisplayIdList(
-      list.begin(), list.end(),
-      [](const display::Display& display) { return display.id(); });
-}
-
-void SortDisplayIdList(display::DisplayIdList* ids) {
-  std::sort(ids->begin(), ids->end(),
-            [](int64_t a, int64_t b) { return CompareDisplayIds(a, b); });
-}
-
-std::string DisplayIdListToString(const display::DisplayIdList& list) {
-  std::stringstream s;
-  const char* sep = "";
-  for (int64_t id : list) {
-    s << sep << id;
-    sep = ",";
-  }
-  return s.str();
-}
-
-bool CompareDisplayIds(int64_t id1, int64_t id2) {
-  DCHECK_NE(id1, id2);
-  // Output index is stored in the first 8 bits. See GetDisplayIdFromEDID
-  // in edid_parser.cc.
-  int index_1 = id1 & 0xFF;
-  int index_2 = id2 & 0xFF;
-  DCHECK_NE(index_1, index_2) << id1 << " and " << id2;
-  return display::Display::IsInternalDisplayId(id1) ||
-         (index_1 < index_2 && !display::Display::IsInternalDisplayId(id2));
-}
 
 #if defined(OS_CHROMEOS)
 void ShowDisplayErrorNotification(int message_id) {
   // Always remove the notification to make sure the notification appears
   // as a popup in any situation.
   message_center::MessageCenter::Get()->RemoveNotification(
       kDisplayErrorNotificationId, false /* by_user */);
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   std::unique_ptr<message_center::Notification> notification(
@@ skipping 17 matching lines @@
   message_center::NotificationList::Notifications notifications =
       message_center::MessageCenter::Get()->GetVisibleNotifications();
   for (auto* const notification : notifications) {
     if (notification->id() == kDisplayErrorNotificationId)
       return notification->message();
   }
   return base::string16();
 }
 
 }  // namespace ash