(fix landed) Reland of name MaximizeMode to TabletMode

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
deleted file mode 100644
index cf6bb66e3fb045e9b2b0105506574dd5b3937240..0000000000000000000000000000000000000000
--- a/ash/wm/maximize_mode/maximize_mode_controller_unittest.cc
+++ /dev/null
@@ -1,671 +0,0 @@
-// 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 <math.h>
-#include <utility>
-#include <vector>
-
-#include "ash/ash_switches.h"
-#include "ash/display/screen_orientation_controller_chromeos.h"
-#include "ash/shell.h"
-#include "ash/system/tray/system_tray_delegate.h"
-#include "ash/test/ash_test_base.h"
-#include "ash/test/test_system_tray_delegate.h"
-#include "ash/wm/overview/window_selector_controller.h"
-#include "base/command_line.h"
-#include "base/run_loop.h"
-#include "base/test/simple_test_tick_clock.h"
-#include "base/test/user_action_tester.h"
-#include "chromeos/accelerometer/accelerometer_reader.h"
-#include "chromeos/accelerometer/accelerometer_types.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/fake_power_manager_client.h"
-#include "ui/display/manager/display_manager.h"
-#include "ui/display/screen.h"
-#include "ui/display/test/display_manager_test_api.h"
-#include "ui/events/event_handler.h"
-#include "ui/events/test/event_generator.h"
-#include "ui/gfx/geometry/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 {
-
-namespace {
-
-const float kDegreesToRadians = 3.1415926f / 180.0f;
-const float kMeanGravity = 9.8066f;
-
-const char kTouchViewInitiallyDisabled[] = "Touchview_Initially_Disabled";
-const char kTouchViewEnabled[] = "Touchview_Enabled";
-const char kTouchViewDisabled[] = "Touchview_Disabled";
-
-}  // namespace
-
-// Test accelerometer data taken with the lid at less than 180 degrees while
-// shaking the device around. The data is to be interpreted in groups of 6 where
-// each 6 values corresponds to the base accelerometer (-y / g, -x / g, -z / g)
-// followed by the lid accelerometer (-y / g , x / g, z / g).
-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 base accelerometer (-y / g, -x / g, -z / g)
-// followed by the lid accelerometer (-y / g , x / g, z / g).
-extern const float kAccelerometerFullyOpenTestData[];
-extern const size_t kAccelerometerFullyOpenTestDataLength;
-
-// Test accelerometer data taken with the lid open 360 degrees while the device
-// hinge was nearly vertical, 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 kAccelerometerVerticalHingeTestData[];
-extern const size_t kAccelerometerVerticalHingeTestDataLength;
-extern const float kAccelerometerVerticalHingeUnstableAnglesTestData[];
-extern const size_t kAccelerometerVerticalHingeUnstableAnglesTestDataLength;
-
-class MaximizeModeControllerTest : public test::AshTestBase {
- public:
-  MaximizeModeControllerTest() {}
-  ~MaximizeModeControllerTest() override {}
-
-  void SetUp() override {
-    base::CommandLine::ForCurrentProcess()->AppendSwitch(
-        switches::kAshEnableTouchView);
-    test::AshTestBase::SetUp();
-    chromeos::AccelerometerReader::GetInstance()->RemoveObserver(
-        maximize_mode_controller());
-
-    // Set the first display to be the internal display for the accelerometer
-    // screen rotation tests.
-    display::test::DisplayManagerTestApi(Shell::Get()->display_manager())
-        .SetFirstDisplayAsInternalDisplay();
-  }
-
-  void TearDown() override {
-    chromeos::AccelerometerReader::GetInstance()->AddObserver(
-        maximize_mode_controller());
-    test::AshTestBase::TearDown();
-  }
-
-  MaximizeModeController* maximize_mode_controller() {
-    return Shell::Get()->maximize_mode_controller();
-  }
-
-  void TriggerLidUpdate(const gfx::Vector3dF& lid) {
-    scoped_refptr<chromeos::AccelerometerUpdate> update(
-        new chromeos::AccelerometerUpdate());
-    update->Set(chromeos::ACCELEROMETER_SOURCE_SCREEN, lid.x(), lid.y(),
-                lid.z());
-    maximize_mode_controller()->OnAccelerometerUpdated(update);
-  }
-
-  void TriggerBaseAndLidUpdate(const gfx::Vector3dF& base,
-                               const gfx::Vector3dF& lid) {
-    scoped_refptr<chromeos::AccelerometerUpdate> update(
-        new chromeos::AccelerometerUpdate());
-    update->Set(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD, base.x(),
-                base.y(), base.z());
-    update->Set(chromeos::ACCELEROMETER_SOURCE_SCREEN, lid.x(), lid.y(),
-                lid.z());
-    maximize_mode_controller()->OnAccelerometerUpdated(update);
-  }
-
-  bool IsMaximizeModeStarted() {
-    return maximize_mode_controller()->IsMaximizeModeWindowManagerEnabled();
-  }
-
-  // Attaches a SimpleTestTickClock to the MaximizeModeController with a non
-  // null value initial value.
-  void AttachTickClockForTest() {
-    std::unique_ptr<base::TickClock> tick_clock(
-        test_tick_clock_ = new base::SimpleTestTickClock());
-    test_tick_clock_->Advance(base::TimeDelta::FromSeconds(1));
-    maximize_mode_controller()->SetTickClockForTest(std::move(tick_clock));
-  }
-
-  void AdvanceTickClock(const base::TimeDelta& delta) {
-    DCHECK(test_tick_clock_);
-    test_tick_clock_->Advance(delta);
-  }
-
-  void OpenLidToAngle(float degrees) {
-    DCHECK(degrees >= 0.0f);
-    DCHECK(degrees <= 360.0f);
-
-    float radians = degrees * kDegreesToRadians;
-    gfx::Vector3dF base_vector(0.0f, -kMeanGravity, 0.0f);
-    gfx::Vector3dF lid_vector(0.0f, kMeanGravity * cos(radians),
-                              kMeanGravity * sin(radians));
-    TriggerBaseAndLidUpdate(base_vector, lid_vector);
-  }
-
-  void HoldDeviceVertical() {
-    gfx::Vector3dF base_vector(9.8f, 0.0f, 0.0f);
-    gfx::Vector3dF lid_vector(9.8f, 0.0f, 0.0f);
-    TriggerBaseAndLidUpdate(base_vector, lid_vector);
-  }
-
-  void OpenLid() {
-    maximize_mode_controller()->LidEventReceived(
-        chromeos::PowerManagerClient::LidState::OPEN,
-        maximize_mode_controller()->tick_clock_->NowTicks());
-  }
-
-  void CloseLid() {
-    maximize_mode_controller()->LidEventReceived(
-        chromeos::PowerManagerClient::LidState::CLOSED,
-        maximize_mode_controller()->tick_clock_->NowTicks());
-  }
-
-  bool WasLidOpenedRecently() {
-    return maximize_mode_controller()->WasLidOpenedRecently();
-  }
-
-  void SetTabletMode(bool on) {
-    maximize_mode_controller()->TabletModeEventReceived(
-        on ? chromeos::PowerManagerClient::TabletMode::ON
-           : chromeos::PowerManagerClient::TabletMode::OFF,
-        maximize_mode_controller()->tick_clock_->NowTicks());
-  }
-
-  bool AreEventsBlocked() {
-    return !!maximize_mode_controller()->event_blocker_.get();
-  }
-
-  MaximizeModeController::ForceTabletMode forced_tablet_mode() {
-    return maximize_mode_controller()->force_tablet_mode_;
-  }
-
-  base::UserActionTester* user_action_tester() { return &user_action_tester_; }
-
- private:
-  base::SimpleTestTickClock* test_tick_clock_;
-
-  // Tracks user action counts.
-  base::UserActionTester user_action_tester_;
-
-  DISALLOW_COPY_AND_ASSIGN(MaximizeModeControllerTest);
-};
-
-// Verify TouchView enabled/disabled user action metrics are recorded.
-TEST_F(MaximizeModeControllerTest, VerifyTouchViewEnabledDisabledCounts) {
-  ASSERT_EQ(1,
-            user_action_tester()->GetActionCount(kTouchViewInitiallyDisabled));
-  ASSERT_EQ(0, user_action_tester()->GetActionCount(kTouchViewEnabled));
-  ASSERT_EQ(0, user_action_tester()->GetActionCount(kTouchViewDisabled));
-
-  user_action_tester()->ResetCounts();
-  maximize_mode_controller()->EnableMaximizeModeWindowManager(true);
-  EXPECT_EQ(1, user_action_tester()->GetActionCount(kTouchViewEnabled));
-  EXPECT_EQ(0, user_action_tester()->GetActionCount(kTouchViewDisabled));
-  maximize_mode_controller()->EnableMaximizeModeWindowManager(true);
-  EXPECT_EQ(1, user_action_tester()->GetActionCount(kTouchViewEnabled));
-  EXPECT_EQ(0, user_action_tester()->GetActionCount(kTouchViewDisabled));
-
-  user_action_tester()->ResetCounts();
-  maximize_mode_controller()->EnableMaximizeModeWindowManager(false);
-  EXPECT_EQ(0, user_action_tester()->GetActionCount(kTouchViewEnabled));
-  EXPECT_EQ(1, user_action_tester()->GetActionCount(kTouchViewDisabled));
-  maximize_mode_controller()->EnableMaximizeModeWindowManager(false);
-  EXPECT_EQ(0, user_action_tester()->GetActionCount(kTouchViewEnabled));
-  EXPECT_EQ(1, user_action_tester()->GetActionCount(kTouchViewDisabled));
-}
-
-// Verify that closing the lid will exit maximize mode.
-TEST_F(MaximizeModeControllerTest, CloseLidWhileInMaximizeMode) {
-  OpenLidToAngle(315.0f);
-  ASSERT_TRUE(IsMaximizeModeStarted());
-
-  CloseLid();
-  EXPECT_FALSE(IsMaximizeModeStarted());
-}
-
-// Verify that maximize mode will not be entered when the lid is closed.
-TEST_F(MaximizeModeControllerTest, HingeAnglesWithLidClosed) {
-  AttachTickClockForTest();
-
-  CloseLid();
-
-  OpenLidToAngle(270.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(315.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(355.0f);
-  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());
-
-  OpenLidToAngle(5.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(355.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  // This is a stable reading and should clear the last lid opened time.
-  OpenLidToAngle(45.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-  EXPECT_FALSE(WasLidOpenedRecently());
-
-  OpenLidToAngle(355.0f);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-}
-
-// Verify the WasLidOpenedRecently signal with respect to time.
-TEST_F(MaximizeModeControllerTest, WasLidOpenedRecentlyOverTime) {
-  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());
-
-  // 3 seconds after lid open.
-  AdvanceTickClock(base::TimeDelta::FromSeconds(2));
-  EXPECT_FALSE(WasLidOpenedRecently());
-}
-
-TEST_F(MaximizeModeControllerTest, TabletModeTransition) {
-  OpenLidToAngle(90.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  // Unstable reading. This should not trigger maximize mode.
-  HoldDeviceVertical();
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  // When tablet mode switch is on it should force maximize mode even if the
-  // reading is not stable.
-  SetTabletMode(true);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  // After tablet mode switch is off it should stay in maximize mode if the
-  // reading is not stable.
-  SetTabletMode(false);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  // Should leave maximize mode when the lid angle is small enough.
-  OpenLidToAngle(90.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(300.0f);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-}
-
-// When there is no keyboard accelerometer available maximize mode should solely
-// rely on the tablet mode switch.
-TEST_F(MaximizeModeControllerTest,
-       TabletModeTransitionNoKeyboardAccelerometer) {
-  ASSERT_FALSE(IsMaximizeModeStarted());
-  TriggerLidUpdate(gfx::Vector3dF(0.0f, 0.0f, kMeanGravity));
-  ASSERT_FALSE(IsMaximizeModeStarted());
-
-  SetTabletMode(true);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  // Single sensor reading should not change mode.
-  TriggerLidUpdate(gfx::Vector3dF(0.0f, 0.0f, kMeanGravity));
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  // With a single sensor we should exit immediately on the tablet mode switch
-  // rather than waiting for stabilized accelerometer readings.
-  SetTabletMode(false);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-}
-
-// Verify the maximize mode enter/exit thresholds for stable angles.
-TEST_F(MaximizeModeControllerTest, StableHingeAnglesWithLidOpened) {
-  ASSERT_FALSE(IsMaximizeModeStarted());
-  ASSERT_FALSE(WasLidOpenedRecently());
-
-  OpenLidToAngle(180.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(315.0f);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(180.0f);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(45.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(270.0f);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(90.0f);
-  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());
-
-  OpenLidToAngle(5.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(355.0f);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(5.0f);
-  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.
-  TriggerBaseAndLidUpdate(gfx::Vector3dF(0.0f, 0.0f, -kMeanGravity),
-                          gfx::Vector3dF(0.0f, -kMeanGravity, 0.0f));
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  // Completely vertical.
-  TriggerBaseAndLidUpdate(gfx::Vector3dF(kMeanGravity, 0.0f, 0.0f),
-                          gfx::Vector3dF(kMeanGravity, 0.0f, 0.0f));
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  // Close to vertical but with hinge appearing to be open 270 degrees.
-  TriggerBaseAndLidUpdate(gfx::Vector3dF(kMeanGravity, 0.0f, -0.1f),
-                          gfx::Vector3dF(kMeanGravity, 0.1f, 0.0f));
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  // Flat and open 270 degrees should start maximize mode.
-  TriggerBaseAndLidUpdate(gfx::Vector3dF(0.0f, 0.0f, -kMeanGravity),
-                          gfx::Vector3dF(0.0f, kMeanGravity, 0.0f));
-  EXPECT_TRUE(IsMaximizeModeStarted());
-
-  // Normal 90 degree orientation but near vertical should stay in maximize
-  // mode.
-  TriggerBaseAndLidUpdate(gfx::Vector3dF(kMeanGravity, 0.0f, -0.1f),
-                          gfx::Vector3dF(kMeanGravity, -0.1f, 0.0f));
-  EXPECT_TRUE(IsMaximizeModeStarted());
-}
-
-TEST_F(MaximizeModeControllerTest, LaptopTest) {
-  // Feeds in sample accelerometer data and verifies that there are no
-  // transitions into touchview / maximize mode while shaking the device around
-  // with the hinge at less than 180 degrees. Note the conversion from device
-  // data to accelerometer updates consistent with accelerometer_reader.cc.
-  ASSERT_EQ(0u, kAccelerometerLaptopModeTestDataLength % 6);
-  for (size_t i = 0; i < kAccelerometerLaptopModeTestDataLength / 6; ++i) {
-    gfx::Vector3dF base(-kAccelerometerLaptopModeTestData[i * 6 + 1],
-                        -kAccelerometerLaptopModeTestData[i * 6],
-                        -kAccelerometerLaptopModeTestData[i * 6 + 2]);
-    base.Scale(kMeanGravity);
-    gfx::Vector3dF lid(-kAccelerometerLaptopModeTestData[i * 6 + 4],
-                       kAccelerometerLaptopModeTestData[i * 6 + 3],
-                       kAccelerometerLaptopModeTestData[i * 6 + 5]);
-    lid.Scale(kMeanGravity);
-    TriggerBaseAndLidUpdate(base, lid);
-    // There are a lot of samples, so ASSERT rather than EXPECT to only generate
-    // one failure rather than potentially hundreds.
-    ASSERT_FALSE(IsMaximizeModeStarted());
-  }
-}
-
-TEST_F(MaximizeModeControllerTest, MaximizeModeTest) {
-  // Trigger maximize mode by opening to 270 to begin the test in maximize mode.
-  TriggerBaseAndLidUpdate(gfx::Vector3dF(0.0f, 0.0f, kMeanGravity),
-                          gfx::Vector3dF(0.0f, -kMeanGravity, 0.0f));
-  ASSERT_TRUE(IsMaximizeModeStarted());
-
-  // Feeds in sample accelerometer data and verifies that there are no
-  // transitions out of touchview / maximize mode while shaking the device
-  // around. Note the conversion from device data to accelerometer updates
-  // consistent with accelerometer_reader.cc.
-  ASSERT_EQ(0u, kAccelerometerFullyOpenTestDataLength % 6);
-  for (size_t i = 0; i < kAccelerometerFullyOpenTestDataLength / 6; ++i) {
-    gfx::Vector3dF base(-kAccelerometerFullyOpenTestData[i * 6 + 1],
-                        -kAccelerometerFullyOpenTestData[i * 6],
-                        -kAccelerometerFullyOpenTestData[i * 6 + 2]);
-    base.Scale(kMeanGravity);
-    gfx::Vector3dF lid(-kAccelerometerFullyOpenTestData[i * 6 + 4],
-                       kAccelerometerFullyOpenTestData[i * 6 + 3],
-                       kAccelerometerFullyOpenTestData[i * 6 + 5]);
-    lid.Scale(kMeanGravity);
-    TriggerBaseAndLidUpdate(base, lid);
-    // There are a lot of samples, so ASSERT rather than EXPECT to only generate
-    // one failure rather than potentially hundreds.
-    ASSERT_TRUE(IsMaximizeModeStarted());
-  }
-}
-
-TEST_F(MaximizeModeControllerTest, VerticalHingeTest) {
-  // Feeds in sample accelerometer data and verifies that there are no
-  // transitions out of touchview / maximize mode while shaking the device
-  // around, while the hinge is nearly vertical. The data was captured from
-  // maxmimize_mode_controller.cc and does not require conversion.
-  ASSERT_EQ(0u, kAccelerometerVerticalHingeTestDataLength % 6);
-  for (size_t i = 0; i < kAccelerometerVerticalHingeTestDataLength / 6; ++i) {
-    gfx::Vector3dF base(kAccelerometerVerticalHingeTestData[i * 6],
-                        kAccelerometerVerticalHingeTestData[i * 6 + 1],
-                        kAccelerometerVerticalHingeTestData[i * 6 + 2]);
-    gfx::Vector3dF lid(kAccelerometerVerticalHingeTestData[i * 6 + 3],
-                       kAccelerometerVerticalHingeTestData[i * 6 + 4],
-                       kAccelerometerVerticalHingeTestData[i * 6 + 5]);
-    TriggerBaseAndLidUpdate(base, lid);
-    // There are a lot of samples, so ASSERT rather than EXPECT to only generate
-    // one failure rather than potentially hundreds.
-    ASSERT_TRUE(IsMaximizeModeStarted());
-  }
-}
-
-// Test if this case does not crash. See http://crbug.com/462806
-TEST_F(MaximizeModeControllerTest, DisplayDisconnectionDuringOverview) {
-  UpdateDisplay("800x600,800x600");
-  std::unique_ptr<aura::Window> w1(
-      CreateTestWindowInShellWithBounds(gfx::Rect(0, 0, 100, 100)));
-  std::unique_ptr<aura::Window> w2(
-      CreateTestWindowInShellWithBounds(gfx::Rect(800, 0, 100, 100)));
-  ASSERT_NE(w1->GetRootWindow(), w2->GetRootWindow());
-
-  maximize_mode_controller()->EnableMaximizeModeWindowManager(true);
-  EXPECT_TRUE(Shell::Get()->window_selector_controller()->ToggleOverview());
-
-  UpdateDisplay("800x600");
-  EXPECT_FALSE(Shell::Get()->window_selector_controller()->IsSelecting());
-  EXPECT_EQ(w1->GetRootWindow(), w2->GetRootWindow());
-}
-
-// Test that the disabling of the internal display exits maximize mode, and that
-// while disabled we do not re-enter maximize mode.
-TEST_F(MaximizeModeControllerTest, NoMaximizeModeWithDisabledInternalDisplay) {
-  UpdateDisplay("200x200, 200x200");
-  const int64_t internal_display_id =
-      display::test::DisplayManagerTestApi(display_manager())
-          .SetFirstDisplayAsInternalDisplay();
-  ASSERT_FALSE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(270.0f);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-  EXPECT_TRUE(AreEventsBlocked());
-
-  // Deactivate internal display to simulate Docked Mode.
-  std::vector<display::ManagedDisplayInfo> secondary_only;
-  secondary_only.push_back(display_manager()->GetDisplayInfo(
-      display_manager()->GetDisplayAt(1).id()));
-  display_manager()->OnNativeDisplaysChanged(secondary_only);
-  ASSERT_FALSE(display_manager()->IsActiveDisplayId(internal_display_id));
-  EXPECT_FALSE(IsMaximizeModeStarted());
-  EXPECT_FALSE(AreEventsBlocked());
-
-  OpenLidToAngle(270.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-  EXPECT_FALSE(AreEventsBlocked());
-
-  // Tablet mode signal should also be ignored.
-  SetTabletMode(true);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-  EXPECT_FALSE(AreEventsBlocked());
-}
-
-// Tests that is a tablet mode signal is received while docked, that maximize
-// mode is enabled upon exiting docked mode.
-TEST_F(MaximizeModeControllerTest, MaximizeModeAfterExitingDockedMode) {
-  UpdateDisplay("200x200, 200x200");
-  const int64_t internal_display_id =
-      display::test::DisplayManagerTestApi(display_manager())
-          .SetFirstDisplayAsInternalDisplay();
-  ASSERT_FALSE(IsMaximizeModeStarted());
-
-  // Deactivate internal display to simulate Docked Mode.
-  std::vector<display::ManagedDisplayInfo> all_displays;
-  all_displays.push_back(display_manager()->GetDisplayInfo(
-      display_manager()->GetDisplayAt(0).id()));
-  std::vector<display::ManagedDisplayInfo> secondary_only;
-  display::ManagedDisplayInfo secondary_display =
-      display_manager()->GetDisplayInfo(
-          display_manager()->GetDisplayAt(1).id());
-  all_displays.push_back(secondary_display);
-  secondary_only.push_back(secondary_display);
-  display_manager()->OnNativeDisplaysChanged(secondary_only);
-  ASSERT_FALSE(display_manager()->IsActiveDisplayId(internal_display_id));
-
-  // Tablet mode signal should also be ignored.
-  SetTabletMode(true);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-  EXPECT_FALSE(AreEventsBlocked());
-
-  // Exiting docked state
-  display_manager()->OnNativeDisplaysChanged(all_displays);
-  display::test::DisplayManagerTestApi(display_manager())
-      .SetFirstDisplayAsInternalDisplay();
-  EXPECT_TRUE(IsMaximizeModeStarted());
-}
-
-// Verify that the device won't exit touchview / maximize mode for unstable
-// angles when hinge is nearly vertical
-TEST_F(MaximizeModeControllerTest, VerticalHingeUnstableAnglesTest) {
-  // Trigger maximize mode by opening to 270 to begin the test in maximize mode.
-  TriggerBaseAndLidUpdate(gfx::Vector3dF(0.0f, 0.0f, kMeanGravity),
-                          gfx::Vector3dF(0.0f, -kMeanGravity, 0.0f));
-  ASSERT_TRUE(IsMaximizeModeStarted());
-
-  // Feeds in sample accelerometer data and verifies that there are no
-  // transitions out of touchview / maximize mode while shaking the device
-  // around, while the hinge is nearly vertical. The data was captured
-  // from maxmimize_mode_controller.cc and does not require conversion.
-  ASSERT_EQ(0u, kAccelerometerVerticalHingeUnstableAnglesTestDataLength % 6);
-  for (size_t i = 0;
-       i < kAccelerometerVerticalHingeUnstableAnglesTestDataLength / 6; ++i) {
-    gfx::Vector3dF base(
-        kAccelerometerVerticalHingeUnstableAnglesTestData[i * 6],
-        kAccelerometerVerticalHingeUnstableAnglesTestData[i * 6 + 1],
-        kAccelerometerVerticalHingeUnstableAnglesTestData[i * 6 + 2]);
-    gfx::Vector3dF lid(
-        kAccelerometerVerticalHingeUnstableAnglesTestData[i * 6 + 3],
-        kAccelerometerVerticalHingeUnstableAnglesTestData[i * 6 + 4],
-        kAccelerometerVerticalHingeUnstableAnglesTestData[i * 6 + 5]);
-    TriggerBaseAndLidUpdate(base, lid);
-    // There are a lot of samples, so ASSERT rather than EXPECT to only generate
-    // one failure rather than potentially hundreds.
-    ASSERT_TRUE(IsMaximizeModeStarted());
-  }
-}
-
-// Tests that when a MaximizeModeController is created that cached tablet mode
-// state will trigger a mode update.
-TEST_F(MaximizeModeControllerTest, InitializedWhileTabletModeSwitchOn) {
-  base::RunLoop().RunUntilIdle();
-  // FakePowerManagerClient is always installed for tests
-  chromeos::FakePowerManagerClient* power_manager_client =
-      static_cast<chromeos::FakePowerManagerClient*>(
-          chromeos::DBusThreadManager::Get()->GetPowerManagerClient());
-  power_manager_client->set_tablet_mode(
-      chromeos::PowerManagerClient::TabletMode::ON);
-  MaximizeModeController controller;
-  EXPECT_FALSE(controller.IsMaximizeModeWindowManagerEnabled());
-  // PowerManagerClient callback is a posted task.
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(controller.IsMaximizeModeWindowManagerEnabled());
-}
-
-// Verify when the force clamshell mode flag is turned on, opening the lid past
-// 180 degrees or setting tablet mode to true will no turn on maximize mode.
-TEST_F(MaximizeModeControllerTest, ForceClamshellModeTest) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-      switches::kAshForceTabletMode, switches::kAshForceTabletModeClamshell);
-  maximize_mode_controller()->OnShellInitialized();
-  EXPECT_EQ(MaximizeModeController::ForceTabletMode::CLAMSHELL,
-            forced_tablet_mode());
-  EXPECT_FALSE(IsMaximizeModeStarted());
-
-  OpenLidToAngle(300.0f);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-  EXPECT_FALSE(AreEventsBlocked());
-
-  SetTabletMode(true);
-  EXPECT_FALSE(IsMaximizeModeStarted());
-  EXPECT_FALSE(AreEventsBlocked());
-}
-
-// Verify when the force touch view mode flag is turned on, maximize mode is on
-// intially, and opening the lid to less than 180 degress or setting tablet mode
-// to off will not turn off maximize mode.
-TEST_F(MaximizeModeControllerTest, ForceTouchViewModeTest) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-      switches::kAshForceTabletMode, switches::kAshForceTabletModeTouchView);
-  maximize_mode_controller()->OnShellInitialized();
-  EXPECT_EQ(MaximizeModeController::ForceTabletMode::TOUCHVIEW,
-            forced_tablet_mode());
-  EXPECT_TRUE(IsMaximizeModeStarted());
-  EXPECT_TRUE(AreEventsBlocked());
-
-  OpenLidToAngle(30.0f);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-  EXPECT_TRUE(AreEventsBlocked());
-
-  SetTabletMode(false);
-  EXPECT_TRUE(IsMaximizeModeStarted());
-  EXPECT_TRUE(AreEventsBlocked());
-}
-
-TEST_F(MaximizeModeControllerTest, RestoreAfterExit) {
-  UpdateDisplay("1000x600");
-  std::unique_ptr<aura::Window> w1(
-      CreateTestWindowInShellWithBounds(gfx::Rect(10, 10, 900, 300)));
-  maximize_mode_controller()->EnableMaximizeModeWindowManager(true);
-  Shell::Get()->screen_orientation_controller()->SetLockToRotation(
-      display::Display::ROTATE_90);
-  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
-  EXPECT_EQ(display::Display::ROTATE_90, display.rotation());
-  EXPECT_LT(display.size().width(), display.size().height());
-  maximize_mode_controller()->EnableMaximizeModeWindowManager(false);
-  display = display::Screen::GetScreen()->GetPrimaryDisplay();
-  // Sanity checks.
-  EXPECT_EQ(display::Display::ROTATE_0, display.rotation());
-  EXPECT_GT(display.size().width(), display.size().height());
-
-  // The bounds should be restored to the original bounds, and
-  // should not be clamped by the portrait display in touch view.
-  EXPECT_EQ(gfx::Rect(10, 10, 900, 300), w1->bounds());
-}
-
-}  // namespace ash