1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
7 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
9 #include "ash/ash_switches.h"
10 #include "ash/display/display_manager.h"
11 #include "ash/shell.h"
12 #include "ash/system/tray/system_tray_delegate.h"
13 #include "ash/test/ash_test_base.h"
14 #include "ash/test/display_manager_test_api.h"
15 #include "ash/test/test_system_tray_delegate.h"
16 #include "ash/test/test_volume_control_delegate.h"
17 #include "base/command_line.h"
18 #include "base/test/simple_test_tick_clock.h"
19 #include "chromeos/accelerometer/accelerometer_reader.h"
20 #include "ui/accelerometer/accelerometer_types.h"
21 #include "ui/events/event_handler.h"
22 #include "ui/events/test/event_generator.h"
23 #include "ui/gfx/geometry/vector3d_f.h"
24 #include "ui/message_center/message_center.h"
27 #include "ui/events/test/events_test_utils_x11.h"
34 const float kDegreesToRadians
= 3.1415926f
/ 180.0f
;
35 const float kMeanGravity
= 9.8066f
;
39 // Test accelerometer data taken with the lid at less than 180 degrees while
40 // shaking the device around. The data is to be interpreted in groups of 6 where
41 // each 6 values corresponds to the X, Y, and Z readings from the base and lid
42 // accelerometers in this order.
43 extern const float kAccelerometerLaptopModeTestData
[];
44 extern const size_t kAccelerometerLaptopModeTestDataLength
;
46 // Test accelerometer data taken with the lid open 360 degrees while
47 // shaking the device around. The data is to be interpreted in groups of 6 where
48 // each 6 values corresponds to the X, Y, and Z readings from the base and lid
49 // accelerometers in this order.
50 extern const float kAccelerometerFullyOpenTestData
[];
51 extern const size_t kAccelerometerFullyOpenTestDataLength
;
53 class MaximizeModeControllerTest
: public test::AshTestBase
{
55 MaximizeModeControllerTest() {}
56 ~MaximizeModeControllerTest() override
{}
58 void SetUp() override
{
59 test::AshTestBase::SetUp();
60 Shell::GetInstance()->accelerometer_reader()->RemoveObserver(
61 maximize_mode_controller());
63 // Set the first display to be the internal display for the accelerometer
64 // screen rotation tests.
65 test::DisplayManagerTestApi(Shell::GetInstance()->display_manager()).
66 SetFirstDisplayAsInternalDisplay();
69 void TearDown() override
{
70 Shell::GetInstance()->accelerometer_reader()->AddObserver(
71 maximize_mode_controller());
72 test::AshTestBase::TearDown();
75 MaximizeModeController
* maximize_mode_controller() {
76 return Shell::GetInstance()->maximize_mode_controller();
79 void TriggerLidUpdate(const gfx::Vector3dF
& lid
) {
80 ui::AccelerometerUpdate update
;
81 update
.Set(ui::ACCELEROMETER_SOURCE_SCREEN
, lid
.x(), lid
.y(), lid
.z());
82 maximize_mode_controller()->OnAccelerometerUpdated(update
);
85 void TriggerBaseAndLidUpdate(const gfx::Vector3dF
& base
,
86 const gfx::Vector3dF
& lid
) {
87 ui::AccelerometerUpdate update
;
88 update
.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD
,
89 base
.x(), base
.y(), base
.z());
90 update
.Set(ui::ACCELEROMETER_SOURCE_SCREEN
,
91 lid
.x(), lid
.y(), lid
.z());
92 maximize_mode_controller()->OnAccelerometerUpdated(update
);
95 bool IsMaximizeModeStarted() {
96 return maximize_mode_controller()->IsMaximizeModeWindowManagerEnabled();
99 gfx::Display::Rotation
GetInternalDisplayRotation() const {
100 return Shell::GetInstance()->display_manager()->GetDisplayInfo(
101 gfx::Display::InternalDisplayId()).rotation();
104 void SetInternalDisplayRotation(gfx::Display::Rotation rotation
) const {
105 Shell::GetInstance()->display_manager()->
106 SetDisplayRotation(gfx::Display::InternalDisplayId(), rotation
);
109 // Attaches a SimpleTestTickClock to the MaximizeModeController with a non
110 // null value initial value.
111 void AttachTickClockForTest() {
112 scoped_ptr
<base::TickClock
> tick_clock(
113 test_tick_clock_
= new base::SimpleTestTickClock());
114 test_tick_clock_
->Advance(base::TimeDelta::FromSeconds(1));
115 maximize_mode_controller()->SetTickClockForTest(tick_clock
.Pass());
118 void AdvanceTickClock(const base::TimeDelta
& delta
) {
119 DCHECK(test_tick_clock_
);
120 test_tick_clock_
->Advance(delta
);
123 void OpenLidToAngle(float degrees
) {
124 DCHECK(degrees
>= 0.0f
);
125 DCHECK(degrees
<= 360.0f
);
127 float radians
= degrees
* kDegreesToRadians
;
128 gfx::Vector3dF
base_vector(0.0f
, -kMeanGravity
, 0.0f
);
129 gfx::Vector3dF
lid_vector(0.0f
,
130 kMeanGravity
* cos(radians
),
131 kMeanGravity
* sin(radians
));
132 TriggerBaseAndLidUpdate(base_vector
, lid_vector
);
136 maximize_mode_controller()->LidEventReceived(true /* open */,
137 maximize_mode_controller()->tick_clock_
->NowTicks());
141 maximize_mode_controller()->LidEventReceived(false /* open */,
142 maximize_mode_controller()->tick_clock_
->NowTicks());
145 bool WasLidOpenedRecently() {
146 return maximize_mode_controller()->WasLidOpenedRecently();
150 base::SimpleTestTickClock
* test_tick_clock_
;
152 DISALLOW_COPY_AND_ASSIGN(MaximizeModeControllerTest
);
155 // Verify that closing the lid will exit maximize mode.
156 TEST_F(MaximizeModeControllerTest
, CloseLidWhileInMaximizeMode
) {
157 OpenLidToAngle(315.0f
);
158 ASSERT_TRUE(IsMaximizeModeStarted());
161 EXPECT_FALSE(IsMaximizeModeStarted());
164 // Verify that maximize mode will not be entered when the lid is closed.
165 TEST_F(MaximizeModeControllerTest
,
166 HingeAnglesWithLidClosed
) {
167 AttachTickClockForTest();
171 OpenLidToAngle(270.0f
);
172 EXPECT_FALSE(IsMaximizeModeStarted());
174 OpenLidToAngle(315.0f
);
175 EXPECT_FALSE(IsMaximizeModeStarted());
177 OpenLidToAngle(355.0f
);
178 EXPECT_FALSE(IsMaximizeModeStarted());
181 // Verify the maximize mode state for unstable hinge angles when the lid was
183 TEST_F(MaximizeModeControllerTest
,
184 UnstableHingeAnglesWhenLidRecentlyOpened
) {
185 AttachTickClockForTest();
188 ASSERT_TRUE(WasLidOpenedRecently());
190 OpenLidToAngle(5.0f
);
191 EXPECT_FALSE(IsMaximizeModeStarted());
193 OpenLidToAngle(355.0f
);
194 EXPECT_FALSE(IsMaximizeModeStarted());
196 // This is a stable reading and should clear the last lid opened time.
197 OpenLidToAngle(45.0f
);
198 EXPECT_FALSE(IsMaximizeModeStarted());
199 EXPECT_FALSE(WasLidOpenedRecently());
201 OpenLidToAngle(355.0f
);
202 EXPECT_TRUE(IsMaximizeModeStarted());
205 // Verify the WasLidOpenedRecently signal with respect to time.
206 TEST_F(MaximizeModeControllerTest
, WasLidOpenedRecentlyOverTime
) {
207 AttachTickClockForTest();
209 // No lid open time initially.
210 ASSERT_FALSE(WasLidOpenedRecently());
213 EXPECT_FALSE(WasLidOpenedRecently());
216 EXPECT_TRUE(WasLidOpenedRecently());
218 // 1 second after lid open.
219 AdvanceTickClock(base::TimeDelta::FromSeconds(1));
220 EXPECT_TRUE(WasLidOpenedRecently());
222 // 3 seconds after lid open.
223 AdvanceTickClock(base::TimeDelta::FromSeconds(2));
224 EXPECT_FALSE(WasLidOpenedRecently());
227 // Verify the maximize mode enter/exit thresholds for stable angles.
228 TEST_F(MaximizeModeControllerTest
, StableHingeAnglesWithLidOpened
) {
229 ASSERT_FALSE(IsMaximizeModeStarted());
230 ASSERT_FALSE(WasLidOpenedRecently());
232 OpenLidToAngle(180.0f
);
233 EXPECT_FALSE(IsMaximizeModeStarted());
235 OpenLidToAngle(315.0f
);
236 EXPECT_TRUE(IsMaximizeModeStarted());
238 OpenLidToAngle(180.0f
);
239 EXPECT_TRUE(IsMaximizeModeStarted());
241 OpenLidToAngle(45.0f
);
242 EXPECT_FALSE(IsMaximizeModeStarted());
244 OpenLidToAngle(270.0f
);
245 EXPECT_TRUE(IsMaximizeModeStarted());
247 OpenLidToAngle(90.0f
);
248 EXPECT_FALSE(IsMaximizeModeStarted());
251 // Verify the maximize mode state for unstable hinge angles when the lid is open
253 TEST_F(MaximizeModeControllerTest
, UnstableHingeAnglesWithLidOpened
) {
254 AttachTickClockForTest();
256 ASSERT_FALSE(WasLidOpenedRecently());
257 ASSERT_FALSE(IsMaximizeModeStarted());
259 OpenLidToAngle(5.0f
);
260 EXPECT_FALSE(IsMaximizeModeStarted());
262 OpenLidToAngle(355.0f
);
263 EXPECT_TRUE(IsMaximizeModeStarted());
265 OpenLidToAngle(5.0f
);
266 EXPECT_TRUE(IsMaximizeModeStarted());
269 // Tests that when the hinge is nearly vertically aligned, the current state
270 // persists as the computed angle is highly inaccurate in this orientation.
271 TEST_F(MaximizeModeControllerTest
, HingeAligned
) {
272 // Laptop in normal orientation lid open 90 degrees.
273 TriggerBaseAndLidUpdate(gfx::Vector3dF(0.0f
, 0.0f
, -kMeanGravity
),
274 gfx::Vector3dF(0.0f
, -kMeanGravity
, 0.0f
));
275 EXPECT_FALSE(IsMaximizeModeStarted());
277 // Completely vertical.
278 TriggerBaseAndLidUpdate(gfx::Vector3dF(kMeanGravity
, 0.0f
, 0.0f
),
279 gfx::Vector3dF(kMeanGravity
, 0.0f
, 0.0f
));
280 EXPECT_FALSE(IsMaximizeModeStarted());
282 // Close to vertical but with hinge appearing to be open 270 degrees.
283 TriggerBaseAndLidUpdate(gfx::Vector3dF(kMeanGravity
, 0.0f
, -0.1f
),
284 gfx::Vector3dF(kMeanGravity
, 0.1f
, 0.0f
));
285 EXPECT_FALSE(IsMaximizeModeStarted());
287 // Flat and open 270 degrees should start maximize mode.
288 TriggerBaseAndLidUpdate(gfx::Vector3dF(0.0f
, 0.0f
, -kMeanGravity
),
289 gfx::Vector3dF(0.0f
, kMeanGravity
, 0.0f
));
290 EXPECT_TRUE(IsMaximizeModeStarted());
292 // Normal 90 degree orientation but near vertical should stay in maximize
294 TriggerBaseAndLidUpdate(gfx::Vector3dF(kMeanGravity
, 0.0f
, -0.1f
),
295 gfx::Vector3dF(kMeanGravity
, -0.1f
, 0.0f
));
296 EXPECT_TRUE(IsMaximizeModeStarted());
299 TEST_F(MaximizeModeControllerTest
, LaptopTest
) {
300 // Feeds in sample accelerometer data and verifies that there are no
301 // transitions into touchview / maximize mode while shaking the device around
302 // with the hinge at less than 180 degrees. Note the conversion from device
303 // data to accelerometer updates consistent with accelerometer_reader.cc.
304 ASSERT_EQ(0u, kAccelerometerLaptopModeTestDataLength
% 6);
305 for (size_t i
= 0; i
< kAccelerometerLaptopModeTestDataLength
/ 6; ++i
) {
306 gfx::Vector3dF
base(-kAccelerometerLaptopModeTestData
[i
* 6 + 1],
307 -kAccelerometerLaptopModeTestData
[i
* 6],
308 -kAccelerometerLaptopModeTestData
[i
* 6 + 2]);
309 base
.Scale(kMeanGravity
);
310 gfx::Vector3dF
lid(-kAccelerometerLaptopModeTestData
[i
* 6 + 4],
311 kAccelerometerLaptopModeTestData
[i
* 6 + 3],
312 kAccelerometerLaptopModeTestData
[i
* 6 + 5]);
313 lid
.Scale(kMeanGravity
);
314 TriggerBaseAndLidUpdate(base
, lid
);
315 // There are a lot of samples, so ASSERT rather than EXPECT to only generate
316 // one failure rather than potentially hundreds.
317 ASSERT_FALSE(IsMaximizeModeStarted());
321 TEST_F(MaximizeModeControllerTest
, MaximizeModeTest
) {
322 // Trigger maximize mode by opening to 270 to begin the test in maximize mode.
323 TriggerBaseAndLidUpdate(gfx::Vector3dF(0.0f
, 0.0f
, kMeanGravity
),
324 gfx::Vector3dF(0.0f
, -kMeanGravity
, 0.0f
));
325 ASSERT_TRUE(IsMaximizeModeStarted());
327 // Feeds in sample accelerometer data and verifies that there are no
328 // transitions out of touchview / maximize mode while shaking the device
329 // around. Note the conversion from device data to accelerometer updates
330 // consistent with accelerometer_reader.cc.
331 ASSERT_EQ(0u, kAccelerometerFullyOpenTestDataLength
% 6);
332 for (size_t i
= 0; i
< kAccelerometerFullyOpenTestDataLength
/ 6; ++i
) {
333 gfx::Vector3dF
base(-kAccelerometerFullyOpenTestData
[i
* 6 + 1],
334 -kAccelerometerFullyOpenTestData
[i
* 6],
335 -kAccelerometerFullyOpenTestData
[i
* 6 + 2]);
336 base
.Scale(kMeanGravity
);
337 gfx::Vector3dF
lid(-kAccelerometerFullyOpenTestData
[i
* 6 + 4],
338 kAccelerometerFullyOpenTestData
[i
* 6 + 3],
339 kAccelerometerFullyOpenTestData
[i
* 6 + 5]);
340 lid
.Scale(kMeanGravity
);
341 TriggerBaseAndLidUpdate(base
, lid
);
342 // There are a lot of samples, so ASSERT rather than EXPECT to only generate
343 // one failure rather than potentially hundreds.
344 ASSERT_TRUE(IsMaximizeModeStarted());
348 class MaximizeModeControllerSwitchesTest
: public MaximizeModeControllerTest
{
350 MaximizeModeControllerSwitchesTest() {}
351 ~MaximizeModeControllerSwitchesTest() override
{}
353 void SetUp() override
{
354 base::CommandLine::ForCurrentProcess()->AppendSwitch(
355 switches::kAshEnableTouchViewTesting
);
356 MaximizeModeControllerTest::SetUp();
359 DISALLOW_COPY_AND_ASSIGN(MaximizeModeControllerSwitchesTest
);
362 // Tests that when the command line switch for testing maximize mode is on, that
363 // accelerometer updates which would normally cause it to exit do not.
364 TEST_F(MaximizeModeControllerSwitchesTest
, IgnoreHingeAngles
) {
365 maximize_mode_controller()->EnableMaximizeModeWindowManager(true);
367 // Would normally trigger an exit from maximize mode.
368 OpenLidToAngle(90.0f
);
369 EXPECT_TRUE(IsMaximizeModeStarted());