Auto rotate on lid rotation changes.

ash/display/display_manager_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_manager.h"
 
+#include "ash/accelerometer/accelerometer_controller.h"
 #include "ash/display/display_controller.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/mirror_window_test_api.h"
 #include "base/format_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/env.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/gfx/display_observer.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/screen_type_delegate.h"
+#include "ui/gfx/vector3d_f.h"
 
 namespace ash {
 namespace internal {
 
 using std::vector;
 using std::string;
 
 using base::StringPrintf;
 
 namespace {
 
 std::string ToDisplayName(int64 id) {
   return "x-" + base::Int64ToString(id);
 }
 
+const float DegreesToRadians(float degrees) {
+  return degrees * 3.1415926f / 180.0f;
+}
+
 }  // namespace
 
 class DisplayManagerTest : public test::AshTestBase,
                            public gfx::DisplayObserver,
                            public aura::WindowObserver {
  public:
   DisplayManagerTest()
       : removed_count_(0U),
         root_window_destroyed_(false) {
   }
   virtual ~DisplayManagerTest() {}
 
   virtual void SetUp() OVERRIDE {
     AshTestBase::SetUp();
     Shell::GetScreen()->AddObserver(this);
     Shell::GetPrimaryRootWindow()->AddObserver(this);
+
+    // Set the primary display to be the internal display for the accelerometer
+    // tests.
+    gfx::Display::SetInternalDisplayId(display_manager()->GetDisplayAt(0).id());
+
+    // Remove the accelerometer observer so that tests can deliver test values.
+    Shell::GetInstance()->accelerometer_controller()->RemoveObserver(
+        display_manager());
   }
   virtual void TearDown() OVERRIDE {
+    Shell::GetInstance()->accelerometer_controller()->AddObserver(
+        display_manager());
     Shell::GetPrimaryRootWindow()->RemoveObserver(this);
     Shell::GetScreen()->RemoveObserver(this);
     AshTestBase::TearDown();
   }
 
   DisplayManager* display_manager() {
     return Shell::GetInstance()->display_manager();
   }
+  const DisplayManager* display_manager() const {
+    return Shell::GetInstance()->display_manager();
+  }
   const vector<gfx::Display>& changed() const { return changed_; }
   const vector<gfx::Display>& added() const { return added_; }
 
   string GetCountSummary() const {
     return StringPrintf("%" PRIuS " %" PRIuS " %" PRIuS,
                         changed_.size(), added_.size(), removed_count_);
   }
 
   void reset() {
     changed_.clear();
     added_.clear();
     removed_count_ = 0U;
     root_window_destroyed_ = false;
   }
 
+  void TriggerAccelerometerUpdate(const gfx::Vector3dF& base,
+                                  const gfx::Vector3dF& lid) {
+    display_manager()->OnAccelerometerUpdated(base, lid);
+  }
+
+  gfx::Display::Rotation GetInternalDisplayRotation() const {
+    return display_manager()->GetDisplayInfo(
+        gfx::Display::InternalDisplayId()).rotation();
+  }
+
   bool root_window_destroyed() const {
     return root_window_destroyed_;
   }
 
   const DisplayInfo& GetDisplayInfo(const gfx::Display& display) {
     return display_manager()->GetDisplayInfo(display.id());
   }
 
   const DisplayInfo& GetDisplayInfoAt(int index) {
     return GetDisplayInfo(display_manager()->GetDisplayAt(index));
@@ skipping 1099 matching lines @@
   EXPECT_EQ("300x400", host1->GetBounds().size().ToString());
 
   UpdateDisplay("100+200-100x200,300+500-200x300");
   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
   EXPECT_EQ("100,200", host0->GetBounds().origin().ToString());
   EXPECT_EQ("100x200", host0->GetBounds().size().ToString());
   EXPECT_EQ("300,500", host1->GetBounds().origin().ToString());
   EXPECT_EQ("200x300", host1->GetBounds().size().ToString());
 }
 
+// Tests that accelerometer readings in each of the screen angles will trigger
+// a rotation of the internal display.
+TEST_F(DisplayManagerTest, AccelerometerRotation) {
+  TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, 1.0f, 0.0f),
+                             gfx::Vector3dF(0.0f, 1.0f, 0.0f));
+  EXPECT_EQ(gfx::Display::ROTATE_90, GetInternalDisplayRotation());
+  TriggerAccelerometerUpdate(gfx::Vector3dF(1.0f, 0.0f, 0.0f),
+                             gfx::Vector3dF(1.0f, 0.0f, 0.0f));
+  EXPECT_EQ(gfx::Display::ROTATE_180, GetInternalDisplayRotation());
+  TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, -1.0f, 0.0f),
+                             gfx::Vector3dF(0.0f, -1.0f, 0.0f));
+  EXPECT_EQ(gfx::Display::ROTATE_270, GetInternalDisplayRotation());
+  TriggerAccelerometerUpdate(gfx::Vector3dF(-1.0f, 0.0f, 0.0f),
+                             gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
+}
+
+// Tests that low angles are ignored by the accelerometer (i.e. when the device
+// is almost laying flat).
+TEST_F(DisplayManagerTest, AccelerometerIgnoresLowAngles) {
+  TriggerAccelerometerUpdate(gfx::Vector3dF(-1.0f, 0.0f, -1.0f),
+                             gfx::Vector3dF(-1.0f, 0.0f, -1.0f));
+  EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
+  TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, 0.2f, -1.0f),
+                             gfx::Vector3dF(0.0f, 0.2f, -1.0f));
+  EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
+  TriggerAccelerometerUpdate(gfx::Vector3dF(0.2f, 0.0f, -1.0f),
+                             gfx::Vector3dF(0.2f, 0.0f, -1.0f));
+  EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
+  TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, -0.2f, -1.0f),
+                             gfx::Vector3dF(0.0f, -0.2f, -1.0f));
+  EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
+  TriggerAccelerometerUpdate(gfx::Vector3dF(-0.2f, 0.0f, -1.0f),
+                             gfx::Vector3dF(-0.2f, 0.0f, -1.0f));
+  EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
+}
+
+// Tests that the display will stick to the current orientation beyond the
+// halfway point, preventing frequent updates back and forth.
+TEST_F(DisplayManagerTest, AccelerometerSticky) {
+  gfx::Vector3dF gravity(-1.0f, 0.0f, 0.0f);
+  TriggerAccelerometerUpdate(gravity, gravity);
+  EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
+
+  // Turn past half-way point to next direction and rotation should remain
+  // the same.
+  float degrees = 50.0;
+  gravity.set_x(-cos(DegreesToRadians(degrees)));
+  gravity.set_y(sin(DegreesToRadians(degrees)));
+  TriggerAccelerometerUpdate(gravity, gravity);
+  EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
+
+  // Turn more and the screen should rotate.
+  degrees = 70.0;
+  gravity.set_x(-cos(DegreesToRadians(degrees)));
+  gravity.set_y(sin(DegreesToRadians(degrees)));
+  TriggerAccelerometerUpdate(gravity, gravity);
+  EXPECT_EQ(gfx::Display::ROTATE_90, GetInternalDisplayRotation());
+
+  // Turn back just beyond the half-way point and the new rotation should
+  // still be in effect.
+  degrees = 40.0;
+  gravity.set_x(-cos(DegreesToRadians(degrees)));
+  gravity.set_y(sin(DegreesToRadians(degrees)));
+  TriggerAccelerometerUpdate(gravity, gravity);
+  EXPECT_EQ(gfx::Display::ROTATE_90, GetInternalDisplayRotation());
+}
 
 class ScreenShutdownTest : public test::AshTestBase {
  public:
   ScreenShutdownTest() {
   }
   virtual ~ScreenShutdownTest() {}
 
   virtual void TearDown() OVERRIDE {
     gfx::Screen* orig_screen =
         gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
@@ skipping 15 matching lines @@
 };
 
 TEST_F(ScreenShutdownTest, ScreenAfterShutdown) {
   if (!SupportsMultipleDisplays())
     return;
   UpdateDisplay("500x300,800x400");
 }
 
 }  // namespace internal
 }  // namespace ash