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

ash/wm/maximize_mode/maximize_mode_controller_unittest.cc

Index: ash/wm/maximize_mode/maximize_mode_controller_unittest.cc
diff --git a/ash/wm/maximize_mode/maximize_mode_controller_unittest.cc b/ash/wm/maximize_mode/maximize_mode_controller_unittest.cc
index 089a2325e8053f0d4ab224d3901f2a856c34dd4a..3d00d7d447a7d8c4d21bd63cd654f7e5248a7bf4 100644
--- a/ash/wm/maximize_mode/maximize_mode_controller_unittest.cc
+++ b/ash/wm/maximize_mode/maximize_mode_controller_unittest.cc
@@ -45,11 +45,42 @@ extern const size_t kAccelerometerLaptopModeTestDataLength;
 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);
+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() {}
+  MaximizeModeControllerTest() : time_tick_provider_stub_(NULL) {}
   virtual ~MaximizeModeControllerTest() {}
 
+  // A test double that allows the current TimeTicks to be explicitly set.
+  class TimeTickProviderStub
+    : public ash::MaximizeModeController::TimeTickProvider {
+   public:
+    TimeTickProviderStub() : TimeTickProvider(), now_() {}
+    virtual ~TimeTickProviderStub() {}
+
+    virtual void SetNow(const base::TimeTicks& now) { now_ = now; }
+
+    // ash::MaximizeModeController::TimeTickProvider:
+    virtual base::TimeTicks Now() const OVERRIDE { return now_; }
+
+   private:
+    base::TimeTicks now_;
+
+    DISALLOW_COPY_AND_ASSIGN(TimeTickProviderStub);
+  };
+
   virtual void SetUp() OVERRIDE {
     test::AshTestBase::SetUp();
     Shell::GetInstance()->accelerometer_controller()->RemoveObserver(
@@ -90,43 +121,184 @@ class MaximizeModeControllerTest : public test::AshTestBase {
         SetDisplayRotation(gfx::Display::InternalDisplayId(), rotation);
   }
 
+  // Attaches a TimeTickProviderStub to the MaximizeModeController with a
+  // non null value initial value.
+  void AttachTimeTicksProviderStub() {
+    time_tick_provider_stub_ = new TimeTickProviderStub();
+    time_tick_provider_stub_->SetNow(base::TimeTicks::FromInternalValue(1));
+    maximize_mode_controller()->SetTimeTickProviderForTest(
+      time_tick_provider_stub_);
+  }
+
+  void SetTimeTicksNow(const base::TimeTicks& now) {
+    DCHECK(time_tick_provider_stub_);
+    time_tick_provider_stub_->SetNow(now);
+  }
+
+  void AddToTimeTicks(const base::TimeDelta delta) {
+    DCHECK(time_tick_provider_stub_);
+    time_tick_provider_stub_->SetNow(
+      time_tick_provider_stub_->Now() + delta);
+  }
+
+  void OpenLid() {
+    maximize_mode_controller()->LidEventReceived(true /* open */,
+      maximize_mode_controller()->time_tick_provider_->Now());
+  }
+
+  void CloseLid() {
+    maximize_mode_controller()->LidEventReceived(false /* open */,
+      maximize_mode_controller()->time_tick_provider_->Now());
+  }
+
+  bool WasLidOpenedRecently() {
+    return maximize_mode_controller()->WasLidOpenedRecently();
+  }
+
  private:
+  TimeTickProviderStub* time_tick_provider_stub_;
+
   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);
+// Verify that closing the lid will exit maximize mode.
+TEST_F(MaximizeModeControllerTest, CloseLidWhileInMaximizeMode) {
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_315);
+  ASSERT_TRUE(IsMaximizeModeStarted());
 
-  // Lid open 90 degrees.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  CloseLid();
   EXPECT_FALSE(IsMaximizeModeStarted());
+}
 
-  // Open just past 180.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(0.05f, 0.0f, -1.0f));
+// Verify the WasLidOpenedRecently signal with respect to time.
+TEST_F(MaximizeModeControllerTest, WasLidOpenedRecently) {
+  AttachTimeTicksProviderStub();
+
+  // No lid open time initially.
+  ASSERT_FALSE(WasLidOpenedRecently());
+
+  CloseLid();
+  EXPECT_FALSE(WasLidOpenedRecently());
+
+  OpenLid();
+  EXPECT_TRUE(WasLidOpenedRecently());
+
+  // 1 second after lid open.
+  AddToTimeTicks(base::TimeDelta::FromSeconds(1));
+  EXPECT_TRUE(WasLidOpenedRecently());
+
+  // 2 seconds after lid open.
+  AddToTimeTicks(base::TimeDelta::FromSeconds(1));
+  EXPECT_TRUE(WasLidOpenedRecently());
+
+  // 3 seconds after lid open.
+  AddToTimeTicks(base::TimeDelta::FromSeconds(1));
+  EXPECT_FALSE(WasLidOpenedRecently());
+}
+
+// Verify that maximize mode will not be entered when the lid is closed.
+TEST_F(MaximizeModeControllerTest,
+    HingeAnglesWithLidClosed) {
+  AttachTimeTicksProviderStub();
+
+  CloseLid();
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_5);
   EXPECT_FALSE(IsMaximizeModeStarted());
 
-  // Open up 270 degrees.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(1.0f, 0.0f, 0.0f));
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_45);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_90);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_180);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  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 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());
 
-  // 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));
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_180);
   EXPECT_TRUE(IsMaximizeModeStarted());
 
-  // Open just before 180.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(-0.05f, 0.0f, -1.0f));
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_45);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_270);
   EXPECT_TRUE(IsMaximizeModeStarted());
 
-  // Open 90 degrees.
-  TriggerAccelerometerUpdate(base, gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_90);
   EXPECT_FALSE(IsMaximizeModeStarted());
 }
 
+// Verify the maximize mode state for unstable hinge angles when the lid
+// was recently open.
+TEST_F(MaximizeModeControllerTest,
+    UnstableHingeAnglesWhenLidRecentlyOpened) {
+  AttachTimeTicksProviderStub();
+
+  OpenLid();
+  ASSERT_TRUE(WasLidOpenedRecently());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_5);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_355);
+  EXPECT_FALSE(IsMaximizeModeStarted());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_5);
+  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());
+
+  TriggerAccelerometerUpdate(kHingeBaseVector, kHingeLidVector_5);
+  EXPECT_TRUE(IsMaximizeModeStarted());
+}
+
+// Verify the maximize mode state for unstable hinge angles when the lid
+// is open but not recently.
+TEST_F(MaximizeModeControllerTest, UnstableHingeAnglesWithLidOpened) {
+  AttachTimeTicksProviderStub();
+
+  OpenLid();
+  AddToTimeTicks(base::TimeDelta::FromSeconds(10));
+  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) {
@@ -275,8 +447,7 @@ TEST_F(MaximizeModeControllerTest, Screenshot) {
   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.
@@ -363,22 +534,17 @@ TEST_F(MaximizeModeControllerTest, RotationLockPreventsRotation) {
 // 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());
 }