Re-implement overscan & Implement Display Rotation

ash/display/display_controller.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_controller.h"
 
 #include <algorithm>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/json/json_value_converter.h"
 #include "base/string_piece.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
+#include "ui/aura/window_property.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 
 #if defined(OS_CHROMEOS)
 #include "ash/display/output_configurator_animation.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "chromeos/display/output_configurator.h"
 #include "ui/base/x/x11_util.h"
 #endif  // defined(OS_CHROMEOS)
 
+DECLARE_WINDOW_PROPERTY_TYPE(ash::internal::DisplayInfo::Rotation);
 
 namespace ash {
 namespace {
 
+DEFINE_WINDOW_PROPERTY_KEY(internal::DisplayInfo::Rotation, kRotationKey,
+                           internal::DisplayInfo::ROTATE_0);
+
 // Primary display stored in global object as it can be
 // accessed after Shell is deleted. A separate display instance is created
 // during the shutdown instead of always keeping two display instances
 // (one here and another one in display_manager) in sync, which is error prone.
 int64 primary_display_id = gfx::Display::kInvalidDisplayID;
 gfx::Display* primary_display_for_shutdown = NULL;
 // Keeps the number of displays during the shutdown after
 // ash::Shell:: is deleted.
 int num_displays_for_shutdown = -1;
 
@@ skipping 45 matching lines @@
     case DisplayLayout::LEFT:
       return std::string("left");
   }
   return std::string("unknown");
 }
 
 internal::DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
+void RotateRootWindow(aura::RootWindow* root_window,
+                      const gfx::Display& display,
+                      const internal::DisplayInfo& info) {
+  // TODO(oshima): Add animation. (crossfade+rotation, or just cross-fade)
+#if defined(OS_WIN)
+  // Windows 8 bots refused to resize the host window, and
+  // updating the transform results in incorrectly resizing
+  // the root window. Don't apply the transform unless
+  // necessary so that unit tests pass on win8 bots.
+  if (info.rotation() == root_window->GetProperty(kRotationKey))
+    return;
+  root_window->SetProperty(kRotationKey, info.rotation());
+#endif
+  gfx::Transform rotate;
+  switch (info.rotation()) {
+    case internal::DisplayInfo::ROTATE_0:
+      break;
+    case internal::DisplayInfo::ROTATE_90:
+      rotate.Translate(display.bounds().height(), 0);
+      rotate.Rotate(90);
+      break;
+    case internal::DisplayInfo::ROTATE_270:
+      rotate.Translate(0, display.bounds().width());
+      rotate.Rotate(270);
+      break;
+    case internal::DisplayInfo::ROTATE_180:
+      rotate.Translate(display.bounds().width(), display.bounds().height());
+      rotate.Rotate(180);
+      break;
+  }
+  root_window->SetTransform(rotate);
+}
+
 void SetDisplayPropertiesOnHostWindow(aura::RootWindow* root,
                                       const gfx::Display& display) {
+  internal::DisplayInfo info = GetDisplayManager()->GetDisplayInfo(display);
 #if defined(OS_CHROMEOS)
   // Native window property (Atom in X11) that specifies the display's
   // rotation and scale factor.  They are read and used by
   // touchpad/mouse driver directly on X (contact adlr@ for more
   // details on touchpad/mouse driver side). The value of the rotation
   // is one of 0 (normal), 1 (90 degrees clockwise), 2 (180 degree) or
   // 3 (270 degrees clockwise).  The value of the scale factor is in
   // percent (100, 140, 200 etc).
   const char kRotationProp[] = "_CHROME_DISPLAY_ROTATION";
   const char kScaleFactorProp[] = "_CHROME_DISPLAY_SCALE_FACTOR";
   const char kCARDINAL[] = "CARDINAL";
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
-  int rotation = 0;
+  int rotation = static_cast<int>(info.rotation());
   if (command_line->HasSwitch(switches::kAshOverrideDisplayOrientation)) {
     std::string value = command_line->
         GetSwitchValueASCII(switches::kAshOverrideDisplayOrientation);
     DCHECK(base::StringToInt(value, &rotation));
     DCHECK(0 <= rotation && rotation <= 3) << "Invalid rotation value="
                                            << rotation;
     if (rotation < 0 || rotation > 3)
       rotation = 0;
   }
   gfx::AcceleratedWidget xwindow = root->GetAcceleratedWidget();
   ui::SetIntProperty(xwindow, kRotationProp, kCARDINAL, rotation);
   ui::SetIntProperty(xwindow,
                      kScaleFactorProp,
                      kCARDINAL,
                      100 * display.device_scale_factor());
 #endif
+  RotateRootWindow(root, display, info);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayLayout
 
 DisplayLayout::DisplayLayout()
     : position(RIGHT),
       offset(0) {}
@@ skipping 80 matching lines @@
 bool DisplayController::DisplayChangeLimiter::IsThrottled() const {
   return base::Time::Now() < throttle_timeout_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayController
 
 DisplayController::DisplayController()
     : desired_primary_display_id_(gfx::Display::kInvalidDisplayID),
       primary_root_window_for_replace_(NULL) {
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
 #if defined(OS_CHROMEOS)
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (!command_line->HasSwitch(switches::kAshDisableDisplayChangeLimiter) &&
       base::chromeos::IsRunningOnChromeOS())
     limiter_.reset(new DisplayChangeLimiter);
 #endif
+  if (command_line->HasSwitch(switches::kAshSecondaryDisplayLayout)) {
+    std::string value = command_line->GetSwitchValueASCII(
+        switches::kAshSecondaryDisplayLayout);
+    char layout;
+    int offset = 0;
+    if (sscanf(value.c_str(), "%c,%d", &layout, &offset) == 2) {
+      if (layout == 't')
+        default_display_layout_.position = DisplayLayout::TOP;
+      else if (layout == 'b')
+        default_display_layout_.position = DisplayLayout::BOTTOM;
+      else if (layout == 'r')
+        default_display_layout_.position = DisplayLayout::RIGHT;
+      else if (layout == 'l')
+        default_display_layout_.position = DisplayLayout::LEFT;
+      default_display_layout_.offset = offset;
+    }
+  }
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
   primary_display_id = gfx::Display::kInvalidDisplayID;
   delete primary_display_for_shutdown;
   primary_display_for_shutdown = NULL;
   num_displays_for_shutdown = -1;
 
   Shell::GetScreen()->AddObserver(this);
 }
 
@@ skipping 49 matching lines @@
 
 void DisplayController::InitSecondaryDisplays() {
   internal::DisplayManager* display_manager = GetDisplayManager();
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const gfx::Display* display = display_manager->GetDisplayAt(i);
     if (primary_display_id != display->id()) {
       aura::RootWindow* root = AddRootWindowForDisplay(*display);
       Shell::GetInstance()->InitRootWindowForSecondaryDisplay(root);
     }
   }
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kAshSecondaryDisplayLayout)) {
-    std::string value = command_line->GetSwitchValueASCII(
-        switches::kAshSecondaryDisplayLayout);
-    char layout;
-    int offset;
-    if (sscanf(value.c_str(), "%c,%d", &layout, &offset) == 2) {
-      if (layout == 't')
-        default_display_layout_.position = DisplayLayout::TOP;
-      else if (layout == 'b')
-        default_display_layout_.position = DisplayLayout::BOTTOM;
-      else if (layout == 'r')
-        default_display_layout_.position = DisplayLayout::RIGHT;
-      else if (layout == 'l')
-        default_display_layout_.position = DisplayLayout::LEFT;
-      default_display_layout_.offset = offset;
-    }
-  }
   UpdateDisplayBoundsForLayout();
 }
 
 void DisplayController::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DisplayController::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
@@ skipping 258 matching lines @@
 gfx::Display* DisplayController::GetSecondaryDisplay() {
   internal::DisplayManager* display_manager = GetDisplayManager();
   CHECK_EQ(2U, display_manager->GetNumDisplays());
   return display_manager->GetDisplayAt(0)->id() == primary_display_id ?
       display_manager->GetDisplayAt(1) : display_manager->GetDisplayAt(0);
 }
 
 void DisplayController::OnDisplayBoundsChanged(const gfx::Display& display) {
   if (limiter_.get())
     limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
-  DCHECK(!GetDisplayManager()->GetDisplayInfo(display).
-         bounds_in_pixel().IsEmpty());
+  const internal::DisplayInfo& display_info =
+      GetDisplayManager()->GetDisplayInfo(display);
+  DCHECK(!display_info.bounds_in_pixel().IsEmpty());
 
   NotifyDisplayConfigurationChanging();
   UpdateDisplayBoundsForLayout();
   aura::RootWindow* root = root_windows_[display.id()];
+  root->SetHostBoundsAndInsets(display_info.bounds_in_pixel(),
+                               display_info.GetOverscanInsetsInPixel());
   SetDisplayPropertiesOnHostWindow(root, display);
-  root->SetHostBounds(
-      GetDisplayManager()->GetDisplayInfo(display).bounds_in_pixel());
 }
 
 void DisplayController::OnDisplayAdded(const gfx::Display& display) {
   if (limiter_.get())
     limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
 
   NotifyDisplayConfigurationChanging();
   if (primary_root_window_for_replace_) {
     DCHECK(root_windows_.empty());
     primary_display_id = display.id();
     root_windows_[display.id()] = primary_root_window_for_replace_;
     primary_root_window_for_replace_->SetProperty(
         internal::kDisplayIdKey, display.id());
     primary_root_window_for_replace_ = NULL;
     UpdateDisplayBoundsForLayout();
-    root_windows_[display.id()]->SetHostBounds(
-        GetDisplayManager()->GetDisplayInfo(display).bounds_in_pixel());
+    const internal::DisplayInfo& display_info =
+        GetDisplayManager()->GetDisplayInfo(display);
+    root_windows_[display.id()]->SetHostBoundsAndInsets(
+        display_info.bounds_in_pixel(),
+        display_info.GetOverscanInsetsInPixel());
   } else {
     DCHECK(!root_windows_.empty());
     aura::RootWindow* root = AddRootWindowForDisplay(display);
     UpdateDisplayBoundsForLayout();
     if (desired_primary_display_id_ == display.id())
       SetPrimaryDisplay(display);
     Shell::GetInstance()->InitRootWindowForSecondaryDisplay(root);
   }
 }
 
@@ skipping 119 matching lines @@
     const DisplayLayout& layout,
     bool override) {
   DisplayIdPair pair;
   pair.first = id1;
   pair.second = id2;
   if (override || paired_layouts_.find(pair) == paired_layouts_.end())
     paired_layouts_[pair] = layout;
 }
 
 }  // namespace ash