Relocate reuseable portions of ash/display/display_util.*

ash/display/display_manager.cc

 // 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.
 
 #include "ash/display/display_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
@@ skipping 19 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/display/display.h"
 #include "ui/display/display_observer.h"
 #include "ui/display/manager/display_layout_store.h"
+#include "ui/display/manager/display_manager_utilities.h"
 #include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/font_render_params.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"  // nogncheck
 #endif
 
@@ skipping 12 matching lines @@
 // We need to keep this in order for unittests to tell if
 // the object in display::Screen::GetScreenByType is for shutdown.
 display::Screen* screen_for_shutdown = nullptr;
 
 // The number of pixels to overlap between the primary and secondary displays,
 // in case that the offset value is too large.
 const int kMinimumOverlapForInvalidOffset = 100;
 
 struct DisplaySortFunctor {
   bool operator()(const display::Display& a, const display::Display& b) {
-    return CompareDisplayIds(a.id(), b.id());
+    return display::CompareDisplayIds(a.id(), b.id());
   }
 };
 
 struct DisplayInfoSortFunctor {
   bool operator()(const display::ManagedDisplayInfo& a,
                   const display::ManagedDisplayInfo& b) {
-    return CompareDisplayIds(a.id(), b.id());
+    return display::CompareDisplayIds(a.id(), b.id());
   }
 };
 
 display::Display& GetInvalidDisplay() {
   static display::Display* invalid_display = new display::Display();
   return *invalid_display;
 }
 
 display::ManagedDisplayInfo::ManagedDisplayModeList::const_iterator
 FindDisplayMode(const display::ManagedDisplayInfo& info,
                 const scoped_refptr<display::ManagedDisplayMode>& target_mode) {
   const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
       info.display_modes();
   return std::find_if(
       modes.begin(), modes.end(),
       [target_mode](const scoped_refptr<display::ManagedDisplayMode>& mode) {
         return target_mode->IsEquivalent(mode);
       });
 }
 
 void SetInternalManagedDisplayModeList(display::ManagedDisplayInfo* info) {
   scoped_refptr<display::ManagedDisplayMode> native_mode =
       new display::ManagedDisplayMode(
           info->bounds_in_native().size(), 0.0 /* refresh_rate */,
           false /* interlaced */, false /* native_mode */, 1.0 /* ui_scale */,
           info->device_scale_factor());
   info->SetManagedDisplayModes(
-      CreateInternalManagedDisplayModeList(native_mode));
+      display::CreateInternalManagedDisplayModeList(native_mode));
 }
 
 void MaybeInitInternalDisplay(display::ManagedDisplayInfo* info) {
   int64_t id = info->id();
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshUseFirstDisplayAsInternal)) {
     display::Display::SetInternalDisplayId(id);
     SetInternalManagedDisplayModeList(info);
   }
 }
@@ skipping 102 matching lines @@
   }
   LOG(ERROR) << "DisplayLayout is requested for single display";
   // On release build, just fallback to default instead of blowing up.
   static display::DisplayLayout layout;
   layout.primary_id = active_display_list_[0].id();
   return layout;
 }
 
 display::DisplayIdList DisplayManager::GetCurrentDisplayIdList() const {
   if (IsInUnifiedMode()) {
-    return CreateDisplayIdList(software_mirroring_display_list_);
+    return display::CreateDisplayIdList(software_mirroring_display_list_);
   } else if (IsInMirrorMode()) {
     if (software_mirroring_enabled()) {
       CHECK_EQ(2u, num_connected_displays());
       // This comment is to make it easy to distinguish the crash
       // between two checks.
       CHECK_EQ(1u, active_display_list_.size());
     }
     int64_t ids[] = {active_display_list_[0].id(), mirroring_display_id_};
-    return ash::GenerateDisplayIdList(std::begin(ids), std::end(ids));
+    return display::GenerateDisplayIdList(std::begin(ids), std::end(ids));
   } else {
     CHECK_LE(2u, active_display_list_.size());
-    return CreateDisplayIdList(active_display_list_);
+    return display::CreateDisplayIdList(active_display_list_);
   }
 }
 
 void DisplayManager::SetLayoutForCurrentDisplays(
     std::unique_ptr<display::DisplayLayout> layout) {
   if (GetNumDisplays() == 1)
     return;
   const display::DisplayIdList list = GetCurrentDisplayIdList();
 
   DCHECK(display::DisplayLayout::Validate(list, *layout));
@@ skipping 24 matching lines @@
 }
 
 const display::Display& DisplayManager::GetDisplayForId(int64_t id) const {
   display::Display* display =
       const_cast<DisplayManager*>(this)->FindDisplayForId(id);
   return display ? *display : GetInvalidDisplay();
 }
 
 const display::Display& DisplayManager::FindDisplayContainingPoint(
     const gfx::Point& point_in_screen) const {
-  int index =
-      FindDisplayIndexContainingPoint(active_display_list_, point_in_screen);
+  int index = display::FindDisplayIndexContainingPoint(active_display_list_,
+                                                       point_in_screen);
   return index < 0 ? GetInvalidDisplay() : active_display_list_[index];
 }
 
 bool DisplayManager::UpdateWorkAreaOfDisplay(int64_t display_id,
                                              const gfx::Insets& insets) {
   display::Display* display = FindDisplayForId(display_id);
   DCHECK(display);
   gfx::Rect old_work_area = display->work_area();
   display->UpdateWorkAreaFromInsets(insets);
   bool workarea_changed = old_work_area != display->work_area();
@@ skipping 790 matching lines @@
 
 void DisplayManager::UpdateInternalManagedDisplayModeListForTest() {
   if (!display::Display::HasInternalDisplay() ||
       display_info_.count(display::Display::InternalDisplayId()) == 0)
     return;
   display::ManagedDisplayInfo* info =
       &display_info_[display::Display::InternalDisplayId()];
   SetInternalManagedDisplayModeList(info);
 }
 
+bool DisplayManager::ZoomInternalDisplay(bool up) {
+  int64_t display_id =
+      IsInUnifiedMode() ? kUnifiedDisplayId : GetDisplayIdForUIScaling();
+  const display::ManagedDisplayInfo& display_info = GetDisplayInfo(display_id);
+
+  scoped_refptr<display::ManagedDisplayMode> mode;
+  if (IsInUnifiedMode()) {
+    mode = GetDisplayModeForNextResolution(display_info, up);
+  } else {
+    if (!IsActiveDisplayId(display_info.id()) ||
+        !display::Display::IsInternalDisplayId(display_info.id())) {
+      return false;
+    }
+    mode = GetDisplayModeForNextUIScale(display_info, up);
+  }
+
+  return mode ? SetDisplayMode(display_id, mode) : false;
+}
+
+void DisplayManager::ResetInternalDisplayZoom() {
+  if (IsInUnifiedMode()) {
+    const display::ManagedDisplayInfo& display_info =
+        GetDisplayInfo(DisplayManager::kUnifiedDisplayId);
+    const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
+        display_info.display_modes();
+    auto iter = std::find_if(
+        modes.begin(), modes.end(),
+        [](const scoped_refptr<display::ManagedDisplayMode>& mode) {
+          return mode->native();
+        });
+    SetDisplayMode(kUnifiedDisplayId, *iter);
+  } else {
+    SetDisplayUIScale(GetDisplayIdForUIScaling(), 1.0f);
+  }
+}
+
 void DisplayManager::CreateSoftwareMirroringDisplayInfo(
     DisplayInfoList* display_info_list) {
   // Use the internal display or 1st as the mirror source, then scale
   // the root window so that it matches the external display's
   // resolution. This is necessary in order for scaling to work while
   // mirrored.
   switch (multi_display_mode_) {
     case MIRRORING: {
       if (display_info_list->size() != 2)
         return;
@@ skipping 219 matching lines @@
 }
 
 void DisplayManager::UpdateNonPrimaryDisplayBoundsForLayout(
     display::DisplayList* display_list,
     std::vector<size_t>* updated_indices) {
   if (display_list->size() == 1u)
     return;
 
   const display::DisplayLayout& layout =
       layout_store_->GetRegisteredDisplayLayout(
-          CreateDisplayIdList(*display_list));
+          display::CreateDisplayIdList(*display_list));
 
   // Ignore if a user has a old format (should be extremely rare)
   // and this will be replaced with DCHECK.
   if (layout.primary_id == display::Display::kInvalidDisplayID)
     return;
 
   // display_list does not have translation set, so ApplyDisplayLayout cannot
   // provide accurate change information. We'll find the changes after the call.
   ApplyDisplayLayout(layout, display_list, nullptr);
   size_t num_displays = display_list->size();
@@ skipping 21 matching lines @@
   layout.ApplyToDisplayList(display_list, updated_ids,
                             kMinimumOverlapForInvalidOffset);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash