Store rotation/ui scale to local state.

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 <set>
 #include <string>
 #include <vector>
 
@@ skipping 36 matching lines @@
 
 DECLARE_WINDOW_PROPERTY_TYPE(int64);
 
 namespace ash {
 namespace internal {
 typedef std::vector<gfx::Display> DisplayList;
 typedef std::vector<DisplayInfo> DisplayInfoList;
 
 namespace {
 
+// List of value UI Scale values. These scales are equivalent to 1024,
+// 1280, 1600 and 1920 pixel width respectively on 2560 pixel width 2x
+// density display.
+const float kUIScales[] = {0.8f, 1.0f, 1.25f, 1.5f};
+const size_t kUIScaleTableSize = arraysize(kUIScales);
+
 struct DisplaySortFunctor {
   bool operator()(const gfx::Display& a, const gfx::Display& b) {
     return a.id() < b.id();
   }
 };
 
 struct DisplayInfoSortFunctor {
   bool operator()(const DisplayInfo& a, const DisplayInfo& b) {
     return a.id() < b.id();
   }
 };
 
 gfx::Display& GetInvalidDisplay() {
   static gfx::Display* invalid_display = new gfx::Display();
   return *invalid_display;
 }
 
+bool IsValidUIScale(float scale) {
+  for (size_t i = 0; i < kUIScaleTableSize; ++i) {
+    if (kUIScales[i] == scale)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 using aura::RootWindow;
 using aura::Window;
 using std::string;
 using std::vector;
 
 DEFINE_WINDOW_PROPERTY_KEY(int64, kDisplayIdKey,
                            gfx::Display::kInvalidDisplayID);
 
@@ skipping 15 matching lines @@
 // static
 void DisplayManager::CycleDisplay() {
   Shell::GetInstance()->display_manager()->CycleDisplayImpl();
 }
 
 // static
 void DisplayManager::ToggleDisplayScaleFactor() {
   Shell::GetInstance()->display_manager()->ScaleDisplayImpl();
 }
 
+// static
+float DisplayManager::GetNextUIScale(float scale, bool up) {
+  for (size_t i = 0; i < kUIScaleTableSize; ++i) {
+    if (kUIScales[i] == scale) {
+      if (up && i != kUIScaleTableSize -1)
+        return kUIScales[i + 1];
+      if (!up && i != 0)
+        return kUIScales[i - 1];
+      return kUIScales[i];
+    }
+  }
+  // Fallback to 1.0f if the |scale| wasn't in the list.
+  return 1.0f;
+}
+
 bool DisplayManager::IsActiveDisplay(const gfx::Display& display) const {
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     if ((*iter).id() == display.id())
       return true;
   }
   return false;
 }
 
 bool DisplayManager::HasInternalDisplay() const {
@@ skipping 30 matching lines @@
 }
 
 void DisplayManager::SetOverscanInsets(int64 display_id,
                                        const gfx::Insets& insets_in_dip) {
   // TODO(oshima): insets has to be rotated according to the
   // the current display rotation.
   display_info_[display_id].SetOverscanInsets(true, insets_in_dip);
   DisplayInfoList display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
-    display_info_list.push_back(GetDisplayInfo(*iter));
+    display_info_list.push_back(GetDisplayInfo(iter->id()));
   }
   UpdateDisplays(display_info_list);
 }
 
 void DisplayManager::ClearCustomOverscanInsets(int64 display_id) {
   display_info_[display_id].clear_has_custom_overscan_insets();
   DisplayInfoList display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
-    display_info_list.push_back(GetDisplayInfo(*iter));
+    display_info_list.push_back(GetDisplayInfo(iter->id()));
   }
   UpdateDisplays(display_info_list);
 }
 
 void DisplayManager::SetDisplayRotation(int64 display_id,
                                         gfx::Display::Rotation rotation) {
   if (!IsDisplayRotationEnabled())
     return;
   DisplayInfoList display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
-    DisplayInfo info = GetDisplayInfo(*iter);
+    DisplayInfo info = GetDisplayInfo(iter->id());
     if (info.id() == display_id) {
       if (info.rotation() == rotation)
         return;
       info.set_rotation(rotation);
     }
     display_info_list.push_back(info);
   }
   UpdateDisplays(display_info_list);
 }
 
 void DisplayManager::SetDisplayUIScale(int64 display_id,
                                        float ui_scale) {
-  if (!IsDisplayUIScalingEnabled())
+  if (!IsDisplayUIScalingEnabled() || !IsValidUIScale(ui_scale))
     return;
+
   DisplayInfoList display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
-    DisplayInfo info = GetDisplayInfo(*iter);
+    DisplayInfo info = GetDisplayInfo(iter->id());
     if (info.id() == display_id) {
       if (info.ui_scale() == ui_scale)
         return;
       info.set_ui_scale(ui_scale);
     }
     display_info_list.push_back(info);
   }
   UpdateDisplays(display_info_list);
 }
 
+void DisplayManager::RegisterDisplayProperty(
+    int64 display_id,
+    gfx::Display::Rotation rotation,
+    float ui_scale,
+    const gfx::Insets* overscan_insets) {
+  display_info_[display_id].set_rotation(rotation);
+
+  if (IsValidUIScale(ui_scale))
+    display_info_[display_id].set_ui_scale(ui_scale);
+  if (overscan_insets)
+    display_info_[display_id].SetOverscanInsets(true, *overscan_insets);
+}
 
 bool DisplayManager::IsDisplayRotationEnabled() const {
   static bool enabled = !CommandLine::ForCurrentProcess()->
       HasSwitch(switches::kAshDisableDisplayRotation);
   return enabled;
 }
 
 bool DisplayManager::IsDisplayUIScalingEnabled() const {
   static bool enabled = !CommandLine::ForCurrentProcess()->
       HasSwitch(switches::kAshDisableUIScaling);
@@ skipping 68 matching lines @@
           false));
       internal_display_info_->SetBounds(gfx::Rect(0, 0, 800, 600));
     }
     new_display_info_list.push_back(*internal_display_info_.get());
     // An internal display is always considered *connected*.
     num_connected_displays_++;
   }
   UpdateDisplays(new_display_info_list);
 }
 
+void DisplayManager::UpdateDisplays() {
+  DisplayInfoList display_info_list;
+  for (DisplayList::const_iterator iter = displays_.begin();
+       iter != displays_.end(); ++iter) {
+    display_info_list.push_back(GetDisplayInfo(iter->id()));
+  }
+  UpdateDisplays(display_info_list);
+}
+
 void DisplayManager::UpdateDisplays(
     const std::vector<DisplayInfo>& updated_display_info_list) {
   DisplayInfoList new_display_info_list = updated_display_info_list;
   std::sort(displays_.begin(), displays_.end(), DisplaySortFunctor());
   std::sort(new_display_info_list.begin(),
             new_display_info_list.end(),
             DisplayInfoSortFunctor());
   DisplayList removed_displays;
   std::vector<size_t> changed_display_indices;
   std::vector<size_t> added_display_indices;
@@ skipping 14 matching lines @@
       new_displays.push_back(
           CreateDisplayFromDisplayInfoById(new_info_iter->id()));
       ++new_info_iter;
     } else if (new_info_iter == new_display_info_list.end()) {
       // more displays in current list.
       removed_displays.push_back(*curr_iter);
       ++curr_iter;
     } else if (curr_iter->id() == new_info_iter->id()) {
       const gfx::Display& current_display = *curr_iter;
       // Copy the info because |CreateDisplayFromInfo| updates the instance.
-      const DisplayInfo current_display_info = GetDisplayInfo(current_display);
+      const DisplayInfo current_display_info =
+          GetDisplayInfo(current_display.id());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       gfx::Display new_display =
           CreateDisplayFromDisplayInfoById(new_info_iter->id());
-      const DisplayInfo& new_display_info = GetDisplayInfo(new_display);
+      const DisplayInfo& new_display_info = GetDisplayInfo(new_display.id());
       // TODO(oshima): Rotating square dislay doesn't work as the size
       // won't change. This doesn't cause a problem now as there is no
       // such display. This will be fixed by comparing the rotation as
       // well when the rotation variable is added to gfx::Display.
       if (force_bounds_changed_ ||
           (current_display_info.bounds_in_pixel() !=
            new_display_info.bounds_in_pixel()) ||
           (current_display.device_scale_factor() !=
            new_display.device_scale_factor()) ||
           (current_display_info.size_in_pixel() !=
@@ skipping 66 matching lines @@
   return index < displays_.size() ? &displays_[index] : NULL;
 }
 
 const gfx::Display* DisplayManager::GetPrimaryDisplayCandidate() const {
   const gfx::Display* primary_candidate = &displays_[0];
 #if defined(OS_CHROMEOS)
   if (base::chromeos::IsRunningOnChromeOS()) {
     // On ChromeOS device, root windows are stacked vertically, and
     // default primary is the one on top.
     int count = GetNumDisplays();
-    int y = GetDisplayInfo(*primary_candidate).bounds_in_pixel().y();
+    int y = GetDisplayInfo(primary_candidate->id()).bounds_in_pixel().y();
     for (int i = 1; i < count; ++i) {
       const gfx::Display* display = &displays_[i];
-      const DisplayInfo& display_info = GetDisplayInfo(*display);
+      const DisplayInfo& display_info = GetDisplayInfo(display->id());
       if (display->IsInternal()) {
         primary_candidate = display;
         break;
       } else if (display_info.bounds_in_pixel().y() < y) {
         primary_candidate = display;
         y = display_info.bounds_in_pixel().y();
       }
     }
   }
 #endif
@@ skipping 37 matching lines @@
     int area = intersect.width() * intersect.height();
     if (area > max) {
       max = area;
       matching = &(*iter);
     }
   }
   // Fallback to the primary display if there is no matching display.
   return matching ? *matching : DisplayController::GetPrimaryDisplay();
 }
 
-const DisplayInfo& DisplayManager::GetDisplayInfo(
-    const gfx::Display& display) const {
+const DisplayInfo& DisplayManager::GetDisplayInfo(int64 display_id) const {
   std::map<int64, DisplayInfo>::const_iterator iter =
-      display_info_.find(display.id());
+      display_info_.find(display_id);
   CHECK(iter != display_info_.end());
   return iter->second;
 }
 
 std::string DisplayManager::GetDisplayNameForId(int64 id) {
   if (id == gfx::Display::kInvalidDisplayID)
     return l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
 
   std::map<int64, DisplayInfo>::const_iterator iter = display_info_.find(id);
   if (iter != display_info_.end() && !iter->second.name().empty())
@@ skipping 30 matching lines @@
   if (displays_.empty())
     AddDisplayFromSpec(std::string() /* default */);
   first_display_id_ = displays_[0].id();
   num_connected_displays_ = displays_.size();
 }
 
 void DisplayManager::CycleDisplayImpl() {
   DCHECK(!displays_.empty());
   std::vector<DisplayInfo> new_display_info_list;
   new_display_info_list.push_back(
-      GetDisplayInfo(DisplayController::GetPrimaryDisplay()));
+      GetDisplayInfo(DisplayController::GetPrimaryDisplay().id()));
   // Add if there is only one display.
   if (displays_.size() == 1) {
     // Layout the 2nd display below the primary as with the real device.
     aura::RootWindow* primary = Shell::GetPrimaryRootWindow();
     gfx::Rect host_bounds =
         gfx::Rect(primary->GetHostOrigin(),  primary->GetHostSize());
     new_display_info_list.push_back(DisplayInfo::CreateFromSpec(
         base::StringPrintf(
             "%d+%d-500x400", host_bounds.x(), host_bounds.bottom())));
   }
   UpdateDisplays(new_display_info_list);
 }
 
 void DisplayManager::ScaleDisplayImpl() {
   DCHECK(!displays_.empty());
   std::vector<DisplayInfo> new_display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
-    DisplayInfo display_info = GetDisplayInfo(*iter);
+    DisplayInfo display_info = GetDisplayInfo(iter->id());
     display_info.set_device_scale_factor(
         display_info.device_scale_factor() == 1.0f ? 2.0f : 1.0f);
     new_display_info_list.push_back(display_info);
   }
   UpdateDisplays(new_display_info_list);
 }
 
 gfx::Display& DisplayManager::FindDisplayForRootWindow(
     const aura::RootWindow* root_window) {
   int64 id = root_window->GetProperty(kDisplayIdKey);
@@ skipping 56 matching lines @@
       aura::client::GetScreenPositionClient(root_window);
   client->ConvertPointFromScreen(root_window, &target_location);
 
   root_window->MoveCursorTo(target_location);
 }
 
 void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info) {
   std::map<int64, DisplayInfo>::iterator info =
       display_info_.find(new_info.id());
   if (info != display_info_.end())
-    info->second.CopyFromNative(new_info);
-  else
+    info->second.Copy(new_info);
+  else {
     display_info_[new_info.id()] = new_info;
+    display_info_[new_info.id()].set_native(false);
+  }
   bool on_chromeos = false;
 #if defined(OS_CHROMEOS)
   on_chromeos = base::chromeos::IsRunningOnChromeOS();
 #endif
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if ((new_info.id() == gfx::Display::InternalDisplayId() || !on_chromeos) &&
       command_line->HasSwitch(switches::kAshInternalDisplayUIScale)) {
     double scale_in_double = 1.0;
     std::string value = CommandLine::ForCurrentProcess()->
         GetSwitchValueASCII(switches::kAshInternalDisplayUIScale);
@@ skipping 16 matching lines @@
   // always (0,0) and the secondary display's bounds will be updated
   // by |DisplayController::UpdateDisplayBoundsForLayout|.
   new_display.SetScaleAndBounds(
       display_info.device_scale_factor(), gfx::Rect(bounds_in_pixel.size()));
   new_display.set_rotation(display_info.rotation());
   return new_display;
 }
 
 }  // namespace internal
 }  // namespace ash