Refactor AccelerometerReader to provide an Observer

ash/wm/maximize_mode/maximize_mode_controller.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/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_table.h"
-#include "ash/accelerometer/accelerometer_controller.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "ash/wm/maximize_mode/maximize_mode_window_manager.h"
 #include "ash/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/tick_clock.h"
@@ skipping 28 matching lines @@
 const float kMinStableAngle = 20.0f;
 const float kMaxStableAngle = 340.0f;
 
 // The time duration to consider the lid to be recently opened.
 // This is used to prevent entering maximize mode if an erroneous accelerometer
 // reading makes the lid appear to be fully open when the user is opening the
 // lid from a closed position.
 const base::TimeDelta kLidRecentlyOpenedDuration =
     base::TimeDelta::FromSeconds(2);
 
-// The mean acceleration due to gravity on Earth in m/s^2.
-const float kMeanGravity = 9.80665f;
-
 // When the device approaches vertical orientation (i.e. portrait orientation)
 // the accelerometers for the base and lid approach the same values (i.e.
 // gravity pointing in the direction of the hinge). When this happens we cannot
 // compute the hinge angle reliably and must turn ignore accelerometer readings.
 // This is the minimum acceleration perpendicular to the hinge under which to
 // detect hinge angle in m/s^2.
 const float kHingeAngleDetectionThreshold = 2.5f;
 
+#if defined(OS_CHROMEOS)
+// The mean acceleration due to gravity on Earth in m/s^2.
+const float kMeanGravity = 9.80665f;
+
 // The maximum deviation from the acceleration expected due to gravity under
 // which to detect hinge angle and screen rotation in m/s^2
 const float kDeviationFromGravityThreshold = 1.0f;
 
 // The maximum deviation between the magnitude of the two accelerometers under
 // which to detect hinge angle and screen rotation in m/s^2. These
 // accelerometers are attached to the same physical device and so should be
 // under the same acceleration.
 const float kNoisyMagnitudeDeviation = 1.0f;
+#endif
 
 // The angle which the screen has to be rotated past before the display will
 // rotate to match it (i.e. 45.0f is no stickiness).
 const float kDisplayRotationStickyAngleDegrees = 60.0f;
 
 // The minimum acceleration in m/s^2 in a direction required to trigger screen
 // rotation. This prevents rapid toggling of rotation when the device is near
 // flat and there is very little screen aligned force on it. The value is
 // effectively the sine of the rise angle required times the acceleration due
 // to gravity, with the current value requiring at least a 25 degree rise.
@@ skipping 29 matching lines @@
 MaximizeModeController::MaximizeModeController()
     : rotation_locked_(false),
       have_seen_accelerometer_data_(false),
       ignore_display_configuration_updates_(false),
       lid_open_past_180_(false),
       shutting_down_(false),
       user_rotation_(gfx::Display::ROTATE_0),
       last_touchview_transition_time_(base::Time::Now()),
       tick_clock_(new base::DefaultTickClock()),
       lid_is_closed_(false) {
-  Shell::GetInstance()->accelerometer_controller()->AddObserver(this);
   Shell::GetInstance()->AddShellObserver(this);
 #if defined(OS_CHROMEOS)
+  Shell::GetInstance()->accelerometer_reader()->AddObserver(this);
   chromeos::DBusThreadManager::Get()->
       GetPowerManagerClient()->AddObserver(this);
 #endif  // OS_CHROMEOS
 }
 
 MaximizeModeController::~MaximizeModeController() {
   Shell::GetInstance()->RemoveShellObserver(this);
-  Shell::GetInstance()->accelerometer_controller()->RemoveObserver(this);
 #if defined(OS_CHROMEOS)
+  Shell::GetInstance()->accelerometer_reader()->RemoveObserver(this);
   chromeos::DBusThreadManager::Get()->
       GetPowerManagerClient()->RemoveObserver(this);
 #endif  // OS_CHROMEOS
 }
 
 void MaximizeModeController::SetRotationLocked(bool rotation_locked) {
   if (rotation_locked_ == rotation_locked)
     return;
   base::AutoReset<bool> auto_ignore_display_configuration_updates(
       &ignore_display_configuration_updates_, true);
@@ skipping 46 matching lines @@
 void MaximizeModeController::AddWindow(aura::Window* window) {
   if (IsMaximizeModeWindowManagerEnabled())
     maximize_mode_window_manager_->AddWindow(window);
 }
 
 void MaximizeModeController::Shutdown() {
   shutting_down_ = true;
   LeaveMaximizeMode();
 }
 
+void MaximizeModeController::OnDisplayConfigurationChanged() {
+  if (ignore_display_configuration_updates_)
+    return;
+  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
+  gfx::Display::Rotation user_rotation =
+      display_manager->GetDisplayInfo(gfx::Display::InternalDisplayId())
+          .rotation();
+  if (user_rotation != current_rotation_) {
+    // A user may change other display configuration settings. When the user
+    // does change the rotation setting, then lock rotation to prevent the
+    // accelerometer from erasing their change.
+    SetRotationLocked(true);
+    user_rotation_ = user_rotation;
+    current_rotation_ = user_rotation;
+  }
+}
+
+#if defined(OS_CHROMEOS)
 void MaximizeModeController::OnAccelerometerUpdated(
     const ui::AccelerometerUpdate& update) {
   bool first_accelerometer_update = !have_seen_accelerometer_data_;
   have_seen_accelerometer_data_ = true;
 
   // Ignore the reading if it appears unstable. The reading is considered
   // unstable if it deviates too much from gravity and/or the magnitude of the
   // reading from the lid differs too much from the reading from the base.
   float lid_magnitude = update.has(ui::ACCELEROMETER_SOURCE_SCREEN) ?
       update.get(ui::ACCELEROMETER_SOURCE_SCREEN).Length() : 0.0f;
@@ skipping 26 matching lines @@
 
   if (first_accelerometer_update) {
     // On the first accelerometer update we will know if we have entered
     // maximize mode or not. Update the preferences to reflect the current
     // state.
     Shell::GetInstance()->display_manager()->
         RegisterDisplayRotationProperties(rotation_locked_, current_rotation_);
   }
 }
 
-void MaximizeModeController::OnDisplayConfigurationChanged() {
-  if (ignore_display_configuration_updates_)
-    return;
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  gfx::Display::Rotation user_rotation = display_manager->
-      GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
-  if (user_rotation != current_rotation_) {
-    // A user may change other display configuration settings. When the user
-    // does change the rotation setting, then lock rotation to prevent the
-    // accelerometer from erasing their change.
-    SetRotationLocked(true);
-    user_rotation_ = user_rotation;
-    current_rotation_ = user_rotation;
-  }
-}
-
-#if defined(OS_CHROMEOS)
 void MaximizeModeController::LidEventReceived(bool open,
                                               const base::TimeTicks& time) {
   if (open)
     last_lid_open_time_ = time;
   lid_is_closed_ = !open;
   LeaveMaximizeMode();
 }
 
 void MaximizeModeController::SuspendImminent() {
   RecordTouchViewStateTransition();
@@ skipping 228 matching lines @@
   return elapsed_time <= kLidRecentlyOpenedDuration;
 }
 
 void MaximizeModeController::SetTickClockForTest(
     scoped_ptr<base::TickClock> tick_clock) {
   DCHECK(tick_clock_);
   tick_clock_ = tick_clock.Pass();
 }
 
 }  // namespace ash