Re-implement overscan & Implement Display Rotation

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 <string>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 65 matching lines @@
 using aura::RootWindow;
 using aura::Window;
 using std::string;
 using std::vector;
 
 DEFINE_WINDOW_PROPERTY_KEY(int64, kDisplayIdKey,
                            gfx::Display::kInvalidDisplayID);
 
 DisplayManager::DisplayManager()
     : first_display_id_(gfx::Display::kInvalidDisplayID),
-      force_bounds_changed_(false) {
+      force_bounds_changed_(false),
+      change_display_upon_host_resize_(false) {
+#if defined(OS_CHROMEOS)
+  change_display_upon_host_resize_ = !base::chromeos::IsRunningOnChromeOS();
+#endif
   Init();
 }
 
 DisplayManager::~DisplayManager() {
 }
 
 // static
 void DisplayManager::CycleDisplay() {
   Shell::GetInstance()->display_manager()->CycleDisplayImpl();
 }
@@ skipping 40 matching lines @@
        iter != displays_.end(); ++iter) {
     const gfx::Display& display = *iter;
     if (display.bounds().Contains(point_in_screen))
       return display;
   }
   return GetInvalidDisplay();
 }
 
 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));
   }
   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));
   }
   UpdateDisplays(display_info_list);
 }
 
+void DisplayManager::SetDisplayRotation(int64 display_id,
+                                        DisplayInfo::Rotation rotation) {
+  DisplayInfoList display_info_list;
+  for (DisplayList::const_iterator iter = displays_.begin();
+       iter != displays_.end(); ++iter) {
+    DisplayInfo info = GetDisplayInfo(*iter);
+    if (info.id() == display_id)
+      info.set_rotation(rotation);
+    display_info_list.push_back(info);
+  }
+  UpdateDisplays(display_info_list);
+}
+
 gfx::Insets DisplayManager::GetOverscanInsets(int64 display_id) const {
   std::map<int64, DisplayInfo>::const_iterator it =
       display_info_.find(display_id);
   return (it != display_info_.end()) ?
       it->second.overscan_insets_in_dip() : gfx::Insets();
 }
 
 void DisplayManager::OnNativeDisplaysChanged(
     const std::vector<DisplayInfo>& updated_displays) {
   if (updated_displays.empty()) {
@@ skipping 31 matching lines @@
       internal_display_info_->SetBounds(gfx::Rect(0, 0, 800, 600));
     }
     new_display_info_list.push_back(*internal_display_info_.get());
   }
 
   UpdateDisplays(new_display_info_list);
 }
 
 void DisplayManager::UpdateDisplays(
     const std::vector<DisplayInfo>& updated_display_info_list) {
-#if defined(OS_CHROMEOS)
-  // Overscan is always enabled when not running on the device
-  // in order for unit tests to work.
-  bool can_overscan =
-      !base::chromeos::IsRunningOnChromeOS() ||
-      (Shell::GetInstance()->output_configurator()->output_state() !=
-       chromeos::STATE_DUAL_MIRROR &&
-       updated_display_info_list.size() == 1);
-#else
-  bool can_overscan = true;
-#endif
   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;
   gfx::Display current_primary;
   if (DisplayController::HasPrimaryDisplay())
     current_primary = DisplayController::GetPrimaryDisplay();
 
   DisplayList::iterator curr_iter = displays_.begin();
   DisplayInfoList::const_iterator new_info_iter = new_display_info_list.begin();
 
   DisplayList new_displays;
   while (curr_iter != displays_.end() ||
          new_info_iter != new_display_info_list.end()) {
     if (curr_iter == displays_.end()) {
       // more displays in new list.
       added_display_indices.push_back(new_displays.size());
-      InsertAndUpdateDisplayInfo(*new_info_iter, can_overscan);
+      InsertAndUpdateDisplayInfo(*new_info_iter);
       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);
-      InsertAndUpdateDisplayInfo(*new_info_iter, can_overscan);
+      InsertAndUpdateDisplayInfo(*new_info_iter);
       gfx::Display new_display =
           CreateDisplayFromDisplayInfoById(new_info_iter->id());
       const DisplayInfo& new_display_info = GetDisplayInfo(new_display);
+      // 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())) {
+           new_display.device_scale_factor()) ||
+          (current_display_info.size_in_pixel() !=
+           new_display.GetSizeInPixel())) {
         changed_display_indices.push_back(new_displays.size());
       }
 
       new_display.UpdateWorkAreaFromInsets(current_display.GetWorkAreaInsets());
       new_displays.push_back(new_display);
       ++curr_iter;
       ++new_info_iter;
     } else if (curr_iter->id() < new_info_iter->id()) {
       // more displays in current list between ids, which means it is deleted.
       removed_displays.push_back(*curr_iter);
       ++curr_iter;
     } else {
       // more displays in new list between ids, which means it is added.
       added_display_indices.push_back(new_displays.size());
-      InsertAndUpdateDisplayInfo(*new_info_iter, can_overscan);
+      InsertAndUpdateDisplayInfo(*new_info_iter);
       new_displays.push_back(
           CreateDisplayFromDisplayInfoById(new_info_iter->id()));
       ++new_info_iter;
     }
   }
 
   // Do not update |displays_| if there's nothing to be updated. Without this,
   // it will not update the display layout, which causes the bug
   // http://crbug.com/155948.
   if (changed_display_indices.empty() && added_display_indices.empty() &&
@@ skipping 24 matching lines @@
 
 #if defined(USE_X11) && defined(OS_CHROMEOS)
   if (!changed_display_indices.empty() && base::chromeos::IsRunningOnChromeOS())
     ui::ClearX11DefaultRootWindow();
 #endif
 }
 
 RootWindow* DisplayManager::CreateRootWindowForDisplay(
     const gfx::Display& display) {
   static int root_window_count = 0;
-  const gfx::Rect& bounds_in_pixel = GetDisplayInfo(display).bounds_in_pixel();
+  const DisplayInfo& display_info = GetDisplayInfo(display);
+  const gfx::Rect& bounds_in_pixel = display_info.bounds_in_pixel();
   RootWindow::CreateParams params(bounds_in_pixel);
   params.host = Shell::GetInstance()->root_window_host_factory()->
       CreateRootWindowHost(bounds_in_pixel);
+  params.initial_insets = display_info.GetOverscanInsetsInPixel();
   aura::RootWindow* root_window = new aura::RootWindow(params);
   root_window->SetName(StringPrintf("RootWindow-%d", root_window_count++));
 
   // No need to remove RootWindowObserver because
   // the DisplayManager object outlives RootWindow objects.
   root_window->AddRootWindowObserver(this);
   root_window->SetProperty(kDisplayIdKey, display.id());
   root_window->Init();
   return root_window;
 }
@@ skipping 86 matching lines @@
   std::map<int64, DisplayInfo>::const_iterator iter =
       display_info_.find(display.id());
   if (iter != display_info_.end() && !iter->second.name().empty())
     return iter->second.name();
 
   return base::StringPrintf("Display %d", static_cast<int>(display.id()));
 }
 
 void DisplayManager::OnRootWindowResized(const aura::RootWindow* root,
                                          const gfx::Size& old_size) {
-  bool user_may_change_root = false;
-#if defined(OS_CHROMEOS)
-  user_may_change_root = !base::chromeos::IsRunningOnChromeOS();
-#endif
-  if (user_may_change_root) {
+  if (change_display_upon_host_resize_) {
     gfx::Display& display = FindDisplayForRootWindow(root);
-    if (display.size() != root->GetHostSize()) {
-      display.SetSize(root->GetHostSize());
-      display_info_[display.id()].UpdateBounds(
-          gfx::Rect(root->GetHostOrigin(), root->GetHostSize()));
+    gfx::Size old_display_size_in_pixel = display.GetSizeInPixel();
+    display_info_[display.id()].SetBounds(
+        gfx::Rect(root->GetHostOrigin(), root->GetHostSize()));
+    const gfx::Size& new_display_size_in_pixel =
+        display_info_[display.id()].size_in_pixel();
+    if (old_display_size_in_pixel != new_display_size_in_pixel) {
+      display.SetSize(new_display_size_in_pixel);
       Shell::GetInstance()->screen()->NotifyBoundsChanged(display);
     }
   }
 }
 
 void DisplayManager::Init() {
   // TODO(oshima): Move this logic to DisplayChangeObserver.
   const string size_str = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kAshHostWindowBounds);
   vector<string> parts;
@@ skipping 52 matching lines @@
        iter != displays_.end(); ++iter) {
     if ((*iter).id() == id)
       return *iter;
   }
   DLOG(WARNING) << "Could not find display:" << id;
   return GetInvalidDisplay();
 }
 
 void DisplayManager::AddDisplayFromSpec(const std::string& spec) {
   DisplayInfo display_info = DisplayInfo::CreateFromSpec(spec);
-  InsertAndUpdateDisplayInfo(display_info, false);
+  InsertAndUpdateDisplayInfo(display_info);
   gfx::Display display = CreateDisplayFromDisplayInfoById(display_info.id());
   displays_.push_back(display);
 }
 
 void DisplayManager::EnsurePointerInDisplays() {
   // Don't try to move the pointer during the boot/startup.
   if (!DisplayController::HasPrimaryDisplay())
     return;
   gfx::Point location_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
   gfx::Point target_location;
@@ skipping 22 matching lines @@
   }
 
   aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
   aura::client::ScreenPositionClient* client =
       aura::client::GetScreenPositionClient(root_window);
   client->ConvertPointFromScreen(root_window, &target_location);
 
   root_window->MoveCursorTo(target_location);
 }
 
-void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info,
-                                                bool can_overscan) {
+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
     display_info_[new_info.id()] = new_info;
 
-  display_info_[new_info.id()].UpdateOverscanInfo(can_overscan);
+  display_info_[new_info.id()].UpdateDisplaySize();
 }
 
 gfx::Display DisplayManager::CreateDisplayFromDisplayInfoById(int64 id) {
   DCHECK(display_info_.find(id) != display_info_.end());
   const DisplayInfo& display_info = display_info_[id];
 
   gfx::Display new_display(display_info.id());
+  gfx::Rect bounds_in_pixel(display_info.size_in_pixel());
+
   new_display.SetScaleAndBounds(
-      display_info.device_scale_factor(), display_info.bounds_in_pixel());
+      display_info.device_scale_factor(), bounds_in_pixel);
 
   // If the display is primary, then simply set the origin to (0,0).
   // The secondary display's bounds will be updated by
   // |DisplayController::UpdateDisplayBoundsForLayout|, so no need
   // to change there.
   if (DisplayController::HasPrimaryDisplay()  &&
       display_info.id() == DisplayController::GetPrimaryDisplay().id()) {
     new_display.set_bounds(gfx::Rect(new_display.bounds().size()));
   }
   return new_display;
 }
 
 }  // namespace internal
 }  // namespace ash