Prevent entering maximize mode when the lid is closed or has recently opened.

ash/wm/maximize_mode/maximize_mode_controller_unittest.cc

 // Copyright 2014 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/wm/maximize_mode/maximize_mode_controller.h"
 
 #include "ash/accelerometer/accelerometer_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/test_lock_state_controller_delegate.h"
 #include "ash/test/test_screenshot_delegate.h"
 #include "ash/test/test_system_tray_delegate.h"
 #include "ash/test/test_volume_control_delegate.h"
+#include "base/test/simple_test_tick_clock.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/vector3d_f.h"
 #include "ui/message_center/message_center.h"
 
 #if defined(USE_X11)
 #include "ui/events/test/events_test_utils_x11.h"
 #endif
 
 namespace ash {
@@ skipping 11 matching lines @@
 extern const float kAccelerometerLaptopModeTestData[];
 extern const size_t kAccelerometerLaptopModeTestDataLength;
 
 // Test accelerometer data taken with the lid open 360 degrees while
 // shaking the device around. The data is to be interpreted in groups of 6 where
 // each 6 values corresponds to the X, Y, and Z readings from the base and lid
 // accelerometers in this order.
 extern const float kAccelerometerFullyOpenTestData[];
 extern const size_t kAccelerometerFullyOpenTestDataLength;
 
+// Test vectors that can be used to make the hinge appear to be near a given
+// angle.  Use TriggerAccelerometerUpdate(kHingeBaseVector, k<#>DegreeVector)
+// where <#> in k<#>DegreeVector is the desired angle. Note the <#> values are
+// approximations and are within +/-1 degree.
+const gfx::Vector3dF kHingeBaseVector(1.0f, 0.0f, 0.0f);

[flackr, 2014/07/31 20:21:41]

Global object types are forbidden:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Static_and_Glo...

You can instead create these as statics on the class or during the test class
setup, although even better would be to define a function like Vector3dF
LidVector(Vector3dF base, float angle) which would let you get the corresponding
lid vector for a base vector. This could be used to clean up most of these
tests.

[bruthig, 2014/08/05 18:06:43]

Done.

+const gfx::Vector3dF kHingeLidVector_5(1.0f, 0.0f, 0.1f);
+const gfx::Vector3dF kHingeLidVector_45(0.75f, 0.0f, 0.75f);
+const gfx::Vector3dF kHingeLidVector_90(0.0f, 0.0f, 1.0f);
+const gfx::Vector3dF kHingeLidVector_180(-1.0f, 0.0f, 0.0f);
+const gfx::Vector3dF kHingeLidVector_270(0.0f, 0.0f, -1.0f);
+const gfx::Vector3dF kHingeLidVector_315(0.75f, 0.0f, -0.75f);
+const gfx::Vector3dF kHingeLidVector_355(1.0f, 0.0f, -0.1f);
+
 class MaximizeModeControllerTest : public test::AshTestBase {
  public:
   MaximizeModeControllerTest() {}
   virtual ~MaximizeModeControllerTest() {}
 
   virtual void SetUp() OVERRIDE {
     test::AshTestBase::SetUp();
     Shell::GetInstance()->accelerometer_controller()->RemoveObserver(
         maximize_mode_controller());
 
@@ skipping 25 matching lines @@
   gfx::Display::Rotation GetInternalDisplayRotation() const {
     return Shell::GetInstance()->display_manager()->GetDisplayInfo(
         gfx::Display::InternalDisplayId()).rotation();
   }
 
   void SetInternalDisplayRotation(gfx::Display::Rotation rotation) const {
     Shell::GetInstance()->display_manager()->
         SetDisplayRotation(gfx::Display::InternalDisplayId(), rotation);
   }
 
+  // Attaches a SimpleTestTickClock to the MaximizeModeController with a non
+  // null value initial value.
+  void AttachTickClockForTest() {
+    scoped_ptr<base::TickClock> tick_clock(
+        test_tick_clock_ = new base::SimpleTestTickClock());
+    test_tick_clock_->Advance(base::TimeDelta::FromSeconds(1));
+    maximize_mode_controller()->SetTickClockForTest(tick_clock.Pass());
+  }
+
+  void AdvanceTickClock(const base::TimeDelta& delta) {
+    DCHECK(test_tick_clock_);
+    test_tick_clock_->Advance(delta);
+  }
+
+#if defined(OS_CHROMEOS)
+  void OpenLid() {
+    maximize_mode_controller()->LidEventReceived(true /* open */,
+      maximize_mode_controller()->tick_clock_->NowTicks());

[flackr, 2014/07/31 20:21:41]

nit: indent 4.

[bruthig, 2014/08/05 18:06:43]

Done.

+  }
+
+  void CloseLid() {
+    maximize_mode_controller()->LidEventReceived(false /* open */,
+      maximize_mode_controller()->tick_clock_->NowTicks());

[flackr, 2014/07/31 20:21:41]

nit: indent 4.

[bruthig, 2014/08/05 18:06:43]

Done.

+  }
+#endif  // OS_CHROMEOS
+
+  bool WasLidOpenedRecently() {
+    return maximize_mode_controller()->WasLidOpenedRecently();
+  }
+
  private:
+  base::SimpleTestTickClock* test_tick_clock_;
+
   DISALLOW_COPY_AND_ASSIGN(MaximizeModeControllerTest);
 };
 
-// Tests that opening the lid beyond 180 will enter touchview, and that it will
-// exit when the lid comes back from 180. Also tests the thresholds, i.e. it
-// will stick to the current mode.
-TEST_F(MaximizeModeControllerTest, EnterExitThresholds) {
-  // For the simple test the base remains steady.
-  gfx::Vector3dF base(0.0f, 0.0f, 1.0f);
+#if defined(OS_CHROMEOS)
 
-  // Lid open 90 degrees.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
-  EXPECT_FALSE(IsMaximizeModeStarted());
+// Verify that closing the lid will exit maximize mode.
+TEST_F(MaximizeModeControllerTest, CloseLidWhileInMaximizeMode) {
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_315);
+  ASSERT_TRUE(IsMaximizeModeStarted());
 
-  // Open just past 180.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(0.05f, 0.0f, -1.0f));
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  // Open up 270 degrees.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(1.0f, 0.0f, 0.0f));
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  // Open up 360 degrees and appearing to be slightly past it (i.e. as if almost
-  // closed).
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(-0.05f, 0.0f, 1.0f));
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  // Open just before 180.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(-0.05f, 0.0f, -1.0f));
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  // Open 90 degrees.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  CloseLid();
   EXPECT_FALSE(IsMaximizeModeStarted());
 }
 
+// Verify that maximize mode will not be entered when the lid is closed.
+TEST_F(MaximizeModeControllerTest,
+    HingeAnglesWithLidClosed) {
+  AttachTickClockForTest();
+
+  CloseLid();
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_270);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_315);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_355);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+}
+
+// Verify the maximize mode state for unstable hinge angles when the lid was
+// recently open.
+TEST_F(MaximizeModeControllerTest,
+    UnstableHingeAnglesWhenLidRecentlyOpened) {
+  AttachTickClockForTest();
+
+  OpenLid();
+  ASSERT_TRUE(WasLidOpenedRecently());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_5);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_355);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  // This is a stable reading and should clear the last lid opened time.
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_45);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+  EXPECT_FALSE(WasLidOpenedRecently());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_355);
+  EXPECT_TRUE(IsMaximizeModeStarted());
+}
+
+#endif  // OS_CHROMEOS
+
+// Verify the WasLidOpenedRecently signal with respect to time.
+TEST_F(MaximizeModeControllerTest, WasLidOpenedRecentlyOverTime) {
+#if defined(OS_CHROMEOS)
+
+  AttachTickClockForTest();
+
+  // No lid open time initially.
+  ASSERT_FALSE(WasLidOpenedRecently());
+
+  CloseLid();
+  EXPECT_FALSE(WasLidOpenedRecently());
+
+  OpenLid();
+  EXPECT_TRUE(WasLidOpenedRecently());
+
+  // 1 second after lid open.
+  AdvanceTickClock(base::TimeDelta::FromSeconds(1));
+  EXPECT_TRUE(WasLidOpenedRecently());
+
+  // 2 seconds after lid open.
+  AdvanceTickClock(base::TimeDelta::FromSeconds(1));
+  EXPECT_TRUE(WasLidOpenedRecently());
+
+  // 3 seconds after lid open.
+  AdvanceTickClock(base::TimeDelta::FromSeconds(1));
+  EXPECT_FALSE(WasLidOpenedRecently());
+
+#else
+
+  EXPECT_FALSE(WasLidOpenedRecently());
+
+#endif  // OS_CHROMEOS
+}
+
+// Verify the maximize mode enter/exit thresholds for stable angles.
+TEST_F(MaximizeModeControllerTest, StableHingeAnglesWithLidOpened) {
+  ASSERT_FALSE(IsMaximizeModeStarted());
+  ASSERT_FALSE(WasLidOpenedRecently());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_180);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_315);
+  EXPECT_TRUE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_180);
+  EXPECT_TRUE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_45);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_270);
+  EXPECT_TRUE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_90);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+}
+
+// Verify the maximize mode state for unstable hinge angles when the lid is open
+// but not recently.
+TEST_F(MaximizeModeControllerTest, UnstableHingeAnglesWithLidOpened) {
+  AttachTickClockForTest();
+
+  ASSERT_FALSE(WasLidOpenedRecently());
+  ASSERT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_5);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_355);
+  EXPECT_TRUE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_5);
+  EXPECT_TRUE(IsMaximizeModeStarted());
+}
+
 // Tests that when the hinge is nearly vertically aligned, the current state
 // persists as the computed angle is highly inaccurate in this orientation.
 TEST_F(MaximizeModeControllerTest, HingeAligned) {
   // Laptop in normal orientation lid open 90 degrees.
   TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, 0.0f, 1.0f),
                              gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
   EXPECT_FALSE(IsMaximizeModeStarted());
 
   // Completely vertical.
   TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, -1.0f, 0.0f),
@@ skipping 10 matching lines @@
                              gfx::Vector3dF(1.0f, 0.0f, 0.0f));
   EXPECT_TRUE(IsMaximizeModeStarted());
 
   // Normal 90 degree orientation but near vertical should stay in maximize
   // mode.
   TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, -1.0f, 0.01f),
                              gfx::Vector3dF(-0.01f, -1.0f, 0.0f));
   EXPECT_TRUE(IsMaximizeModeStarted());
 }
 
-// Tests that accelerometer readings in each of the screen angles will trigger
-// a rotation of the internal display.
+// Tests that accelerometer readings in each of the screen angles will trigger a
+// rotation of the internal display.
 TEST_F(MaximizeModeControllerTest, DisplayRotation) {
   // Trigger maximize mode by opening to 270.
   TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, 0.0f, -1.0f),
                              gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
   ASSERT_TRUE(IsMaximizeModeStarted());
 
   // Now test rotating in all directions.
   TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, 1.0f, 0.0f),
                              gfx::Vector3dF(0.0f, 1.0f, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_90, GetInternalDisplayRotation());
@@ skipping 96 matching lines @@
 // and pressing power.
 TEST_F(MaximizeModeControllerTest, Screenshot) {
   Shell::GetInstance()->lock_state_controller()->SetDelegate(
       new test::TestLockStateControllerDelegate);
   aura::Window* root = Shell::GetPrimaryRootWindow();
   ui::test::EventGenerator event_generator(root, root);
   test::TestScreenshotDelegate* delegate = GetScreenshotDelegate();
   delegate->set_can_take_screenshot(true);
 
   // Open up 270 degrees.
-  TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, 0.0f, 1.0f),
-                             gfx::Vector3dF(1.0f, 0.0f, 0.0f));
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_270);
   ASSERT_TRUE(IsMaximizeModeStarted());
 
   // Pressing power alone does not take a screenshot.
   event_generator.PressKey(ui::VKEY_POWER, 0);
   event_generator.ReleaseKey(ui::VKEY_POWER, 0);
   EXPECT_EQ(0, delegate->handle_take_screenshot_count());
 
   // Holding volume down and pressing power takes a screenshot.
   event_generator.PressKey(ui::VKEY_VOLUME_DOWN, 0);
   event_generator.PressKey(ui::VKEY_POWER, 0);
@@ skipping 66 matching lines @@
   EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
 
   maximize_mode_controller()->SetRotationLocked(false);
   TriggerAccelerometerUpdate(gravity, gravity);
   EXPECT_EQ(gfx::Display::ROTATE_90, GetInternalDisplayRotation());
 }
 
 // Tests that when MaximizeModeController turns off MaximizeMode that on the
 // next accelerometer update the rotation lock is cleared.
 TEST_F(MaximizeModeControllerTest, ExitingMaximizeModeClearRotationLock) {
-  // The base remains steady.
-  gfx::Vector3dF base(0.0f, 0.0f, 1.0f);
-
   // Trigger maximize mode by opening to 270.
-  TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, 0.0f, -1.0f),
-  gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_270);
   ASSERT_TRUE(IsMaximizeModeStarted());
 
   maximize_mode_controller()->SetRotationLocked(true);
 
-  // Open 90 degrees.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_90);
   EXPECT_FALSE(IsMaximizeModeStarted());
 
-  // Send an update that would not relaunch MaximizeMode. 90 degrees.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  // Send an update that would not relaunch MaximizeMode.
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_90);
   EXPECT_FALSE(maximize_mode_controller()->rotation_locked());
 }
 
 // The TrayDisplay class that is responsible for adding/updating MessageCenter
 // notifications is only added to the SystemTray on ChromeOS.
 #if defined(OS_CHROMEOS)
 // Tests that the screen rotation notifications are suppressed when
 // triggered by the accelerometer.
 TEST_F(MaximizeModeControllerTest, BlockRotationNotifications) {
   test::TestSystemTrayDelegate* tray_delegate =
@@ skipping 98 matching lines @@
   // User sets rotation to the same rotation that the display was at when
   // maximize mode was activated.
   SetInternalDisplayRotation(gfx::Display::ROTATE_0);
   // Exit maximize mode
   TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, 0.0f, 1.0f),
                              gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
 }
 
 }  // namespace ash