Refactor AccelerometerReader to provide an Observer

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 <math.h>
 
 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
 
-#include "ash/accelerometer/accelerometer_controller.h"
 #include "ash/ash_switches.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_system_tray_delegate.h"
 #include "ash/test/test_volume_control_delegate.h"
 #include "base/command_line.h"
 #include "base/test/simple_test_tick_clock.h"
+#include "chromeos/accelerometer/accelerometer_reader.h"
 #include "ui/accelerometer/accelerometer_types.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
 
@@ skipping 20 matching lines @@
 extern const float kAccelerometerFullyOpenTestData[];
 extern const size_t kAccelerometerFullyOpenTestDataLength;
 
 class MaximizeModeControllerTest : public test::AshTestBase {
  public:
   MaximizeModeControllerTest() {}
   ~MaximizeModeControllerTest() override {}
 
   void SetUp() override {
     test::AshTestBase::SetUp();
-    Shell::GetInstance()->accelerometer_controller()->RemoveObserver(
+    Shell::GetInstance()->accelerometer_reader()->RemoveObserver(
         maximize_mode_controller());
 
     // Set the first display to be the internal display for the accelerometer
     // screen rotation tests.
     test::DisplayManagerTestApi(Shell::GetInstance()->display_manager()).
         SetFirstDisplayAsInternalDisplay();
   }
 
   void TearDown() override {
-    Shell::GetInstance()->accelerometer_controller()->AddObserver(
+    Shell::GetInstance()->accelerometer_reader()->AddObserver(
         maximize_mode_controller());
     test::AshTestBase::TearDown();
   }
 
   MaximizeModeController* maximize_mode_controller() {
     return Shell::GetInstance()->maximize_mode_controller();
   }
 
   void TriggerLidUpdate(const gfx::Vector3dF& lid) {
     ui::AccelerometerUpdate update;
@@ skipping 44 matching lines @@
     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);
   }
 
-#if defined(OS_CHROMEOS)
   void OpenLid() {
     maximize_mode_controller()->LidEventReceived(true /* open */,
         maximize_mode_controller()->tick_clock_->NowTicks());
   }
 
   void CloseLid() {
     maximize_mode_controller()->LidEventReceived(false /* open */,
         maximize_mode_controller()->tick_clock_->NowTicks());
   }
-#endif  // OS_CHROMEOS
 
   bool WasLidOpenedRecently() {
     return maximize_mode_controller()->WasLidOpenedRecently();
   }
 
  private:
   base::SimpleTestTickClock* test_tick_clock_;
 
   DISALLOW_COPY_AND_ASSIGN(MaximizeModeControllerTest);
 };
 
-#if defined(OS_CHROMEOS)
-
 // 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.
@@ skipping 30 matching lines @@
 
   // 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());
 }
 
-#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());
 
   // 3 seconds after lid open.
   AdvanceTickClock(base::TimeDelta::FromSeconds(2));
   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());
 
   OpenLidToAngle(180.0f);
   EXPECT_FALSE(IsMaximizeModeStarted());
 
@@ skipping 270 matching lines @@
   OpenLidToAngle(90.0f);
   EXPECT_FALSE(IsMaximizeModeStarted());
 
   // Send an update that would not relaunch MaximizeMode.
   OpenLidToAngle(90.0f);
   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 =
       static_cast<test::TestSystemTrayDelegate*>(
           Shell::GetInstance()->system_tray_delegate());
   tray_delegate->set_should_show_display_notification(true);
 
   message_center::MessageCenter* message_center =
       message_center::MessageCenter::Get();
@@ skipping 37 matching lines @@
   // Make sure notifications are blocked when adjusting the screen rotation
   // via the accelerometer while in maximize mode
   // Rotate the screen 90 degrees
   ASSERT_NE(gfx::Display::ROTATE_90, GetInternalDisplayRotation());
   TriggerBaseAndLidUpdate(gfx::Vector3dF(-kMeanGravity, 0.0f, 0.0f),
                           gfx::Vector3dF(-kMeanGravity, 0.0f, 0.0f));
   ASSERT_EQ(gfx::Display::ROTATE_90, GetInternalDisplayRotation());
   EXPECT_EQ(0u, message_center->NotificationCount());
   EXPECT_FALSE(message_center->HasPopupNotifications());
 }
-#endif
 
 // Tests that if a user has set a display rotation that it is restored upon
 // exiting maximize mode.
 TEST_F(MaximizeModeControllerTest, ResetUserRotationUponExit) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
                                       gfx::Display::ROTATE_90);
 
   // Trigger maximize mode
   TriggerBaseAndLidUpdate(gfx::Vector3dF(0.0f, 0.0f, kMeanGravity),
@@ skipping 63 matching lines @@
   // Would normally trigger an exit from maximize mode.
   OpenLidToAngle(90.0f);
   EXPECT_TRUE(IsMaximizeModeStarted());
 
   TriggerBaseAndLidUpdate(gfx::Vector3dF(-kMeanGravity, 0.0f, 0.0f),
                           gfx::Vector3dF(-kMeanGravity, 0.0f, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_90, GetInternalDisplayRotation());
 }
 
 }  // namespace ash