Re-implement overscan & Implement Display Rotation

ash/display/display_controller_unittest.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 "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/cursor_manager_test_api.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
+#include "ui/aura/test/event_generator.h"
 #include "ui/aura/window_tracker.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 
+#if defined(OS_WIN)
+#include "win8/util/win8_util.h"
+#endif
+
 namespace ash {
 namespace test {
 namespace {
 
 class TestObserver : public DisplayController::Observer {
  public:
   TestObserver() : count_(0) {
     Shell::GetInstance()->display_controller()->AddObserver(this);
   }
 
@@ skipping 39 matching lines @@
 
 void SetSecondaryDisplayLayout(DisplayLayout::Position position) {
   SetSecondaryDisplayLayoutAndOffset(position, 0);
 }
 
 class DisplayControllerShutdownTest : public test::AshTestBase {
  public:
   virtual void TearDown() OVERRIDE {
     test::AshTestBase::TearDown();
     // Make sure that primary display is accessible after shutdown.
-    gfx::Display primary = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
+    gfx::Display primary = Shell::GetScreen()->GetPrimaryDisplay();
     EXPECT_EQ("0,0 444x333", primary.bounds().ToString());
-    EXPECT_EQ(2, gfx::Screen::GetNativeScreen()->GetNumDisplays());
+    EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
   }
 };
 
+class TestEventHandler : public ui::EventHandler {
+ public:
+  TestEventHandler() : target_root_(NULL) {}
+  virtual ~TestEventHandler() {}
+
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+    aura::Window* target = static_cast<aura::Window*>(event->target());
+    // Only record when the target is the background which covers
+    // entire root window.
+    if (target->name() != "DesktopBackgroundView")
+      return;
+    mouse_location_ = event->location();
+    target_root_ = target->GetRootWindow();
+    event->StopPropagation();
+  }
+
+  std::string GetLocationAndReset() {
+    std::string result = mouse_location_.ToString();
+    mouse_location_.SetPoint(0, 0);
+    target_root_ = NULL;
+    return result;
+  }
+
+ private:
+  gfx::Point mouse_location_;
+  aura::RootWindow* target_root_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestEventHandler);
+};
+
 }  // namespace
 
 typedef test::AshTestBase DisplayControllerTest;
 
 TEST_F(DisplayControllerShutdownTest, Shutdown) {
   UpdateDisplay("444x333, 200x200");
 }
 
 TEST_F(DisplayControllerTest, SecondaryDisplayLayout) {
   TestObserver observer;
@@ skipping 434 matching lines @@
   EXPECT_EQ("300x400", root_windows[1]->GetHostSize().ToString());
 
   UpdateDisplay("100+200-100x200,300+500-200x300");
   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
   EXPECT_EQ("100,200", root_windows[0]->GetHostOrigin().ToString());
   EXPECT_EQ("100x200", root_windows[0]->GetHostSize().ToString());
   EXPECT_EQ("300,500", root_windows[1]->GetHostOrigin().ToString());
   EXPECT_EQ("200x300", root_windows[1]->GetHostSize().ToString());
 }
 
+#if defined(OS_WIN)
+// TODO(oshima): Windows does not supoprts insets.
+#define MAYBE_OverscanInsets DISABLED_OverscanInsets
+#else
+#define MAYBE_OverscanInsets OverscanInsets
+#endif
+
+TEST_F(DisplayControllerTest, MAYBE_OverscanInsets) {
+  DisplayController* display_controller =
+      Shell::GetInstance()->display_controller();
+  TestEventHandler event_handler;
+  Shell::GetInstance()->AddPreTargetHandler(&event_handler);
+
+  UpdateDisplay("120x200,300x400*2");
+  gfx::Display display1 = Shell::GetScreen()->GetPrimaryDisplay();
+  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
+
+  display_controller->SetOverscanInsets(display1.id(),
+                                        gfx::Insets(10, 15, 20, 25));
+  EXPECT_EQ("0,0 80x170", root_windows[0]->bounds().ToString());
+  EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString());
+  EXPECT_EQ("80,0 150x200",
+            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
+
+  aura::test::EventGenerator generator(root_windows[0]);
+  generator.MoveMouseTo(20, 25);
+  EXPECT_EQ("5,15", event_handler.GetLocationAndReset());
+
+  display_controller->ClearCustomOverscanInsets(display1.id());
+  EXPECT_EQ("0,0 120x200", root_windows[0]->bounds().ToString());
+  EXPECT_EQ("120,0 150x200",
+            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
+
+  generator.MoveMouseTo(30, 20);
+  EXPECT_EQ("30,20", event_handler.GetLocationAndReset());
+
+  Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
+}
+
+TEST_F(DisplayControllerTest, Rotate) {
+#if defined(OS_WIN)
+  // On Win8 Metro mode, the host window can't be resized and
+  // SetTransform updates the window using the orignal host window
+  // size.  Just skip this test on win8, so that this test still rusn
+  // on win7 bots.
+  if (win8::IsSingleWindowMetroMode())
+    return;
+#endif
+
+  DisplayController* display_controller =
+      Shell::GetInstance()->display_controller();
+  internal::DisplayManager* display_manager =
+      Shell::GetInstance()->display_manager();
+  TestEventHandler event_handler;
+  Shell::GetInstance()->AddPreTargetHandler(&event_handler);
+
+  UpdateDisplay("120x200,300x400*2");
+  gfx::Display display1 = Shell::GetScreen()->GetPrimaryDisplay();
+  int64 display2_id = ScreenAsh::GetSecondaryDisplay().id();
+  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
+  aura::test::EventGenerator generator1(root_windows[0]);
+
+  EXPECT_EQ("120x200", root_windows[0]->bounds().size().ToString());
+  EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString());
+  EXPECT_EQ("120,0 150x200",
+            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
+  generator1.MoveMouseTo(50, 40);
+  EXPECT_EQ("50,40", event_handler.GetLocationAndReset());
+
+  display_manager->SetDisplayRotation(display1.id(),
+                                      internal::DisplayInfo::Rotate90);
+  EXPECT_EQ("200x120", root_windows[0]->bounds().size().ToString());
+  EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString());
+  EXPECT_EQ("200,0 150x200",
+            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
+  generator1.MoveMouseTo(50, 40);
+  EXPECT_EQ("40,70", event_handler.GetLocationAndReset());
+
+  DisplayLayout display_layout(DisplayLayout::BOTTOM, 50);
+  display_controller->SetLayoutForCurrentDisplays(display_layout);
+  EXPECT_EQ("50,120 150x200",
+            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
+
+  display_manager->SetDisplayRotation(display2_id,
+                                      internal::DisplayInfo::Rotate270);
+  EXPECT_EQ("200x120", root_windows[0]->bounds().size().ToString());
+  EXPECT_EQ("200x150", root_windows[1]->bounds().size().ToString());
+  EXPECT_EQ("50,120 200x150",
+            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
+
+  aura::test::EventGenerator generator2(root_windows[1]);
+  generator2.MoveMouseTo(50, 40);
+  EXPECT_EQ("180,25", event_handler.GetLocationAndReset());
+  display_manager->SetDisplayRotation(display1.id(),
+                                      internal::DisplayInfo::Rotate180);
+
+  EXPECT_EQ("120x200", root_windows[0]->bounds().size().ToString());
+  EXPECT_EQ("200x150", root_windows[1]->bounds().size().ToString());
+  // Dislay must share at least 100, so the x's offset becomes 20.
+  EXPECT_EQ("20,200 200x150",
+            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
+
+  generator1.MoveMouseTo(50, 40);
+  EXPECT_EQ("70,160", event_handler.GetLocationAndReset());
+
+  Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
+}
+
 }  // namespace test
 }  // namespace ash