Move Screen Rotation from MaximizeModeController to ScreenOrientationController

ash/wm/maximize_mode/maximize_mode_controller.cc

Index: ash/wm/maximize_mode/maximize_mode_controller.cc
diff --git a/ash/wm/maximize_mode/maximize_mode_controller.cc b/ash/wm/maximize_mode/maximize_mode_controller.cc
index 0e4acd7dc9abd7ec9426af8fa9df70d9b0c3e474..d9263b7a62a93bb349bd8a15cc95d9b3ae3eaccd 100644
--- a/ash/wm/maximize_mode/maximize_mode_controller.cc
+++ b/ash/wm/maximize_mode/maximize_mode_controller.cc
@@ -12,7 +12,6 @@
 #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"
@@ -27,6 +26,7 @@
 #endif
 
 #if defined(OS_CHROMEOS)
+#include "ash/content/display/screen_orientation_delegate_chromeos.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #endif  // OS_CHROMEOS
 
@@ -76,6 +76,7 @@ const float kDeviationFromGravityThreshold = 1.0f;
 // under the same acceleration.
 const float kNoisyMagnitudeDeviation = 1.0f;
 
+#if defined(OS_CHROMEOS)
 // 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;
@@ -86,6 +87,7 @@ const float kDisplayRotationStickyAngleDegrees = 60.0f;
 // 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.
 const float kMinimumAccelerationScreenRotation = 4.2f;
+#endif  // OS_CHROMEOS
 
 const float kRadiansToDegrees = 180.0f / 3.14159265f;
 
@@ -115,9 +117,7 @@ float ClockwiseAngleBetweenVectorsInDegrees(const gfx::Vector3dF& base,
 }  // namespace
 
 MaximizeModeController::MaximizeModeController()
-    : rotation_locked_(false),
-      have_seen_accelerometer_data_(false),
-      ignore_display_configuration_updates_(false),
+    : have_seen_accelerometer_data_(false),
       lid_open_past_180_(false),
       shutting_down_(false),
       user_rotation_(gfx::Display::ROTATE_0),
@@ -141,31 +141,6 @@ MaximizeModeController::~MaximizeModeController() {
 #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);
-  rotation_locked_ = rotation_locked;
-  Shell::GetInstance()->display_manager()->
-      RegisterDisplayRotationProperties(rotation_locked_, current_rotation_);
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    OnRotationLockChanged(rotation_locked_));
-}
-
-void MaximizeModeController::LockRotation(gfx::Display::Rotation rotation) {
-  SetRotationLocked(true);
-  SetDisplayRotation(Shell::GetInstance()->display_manager(), rotation);
-}
-
-void MaximizeModeController::AddObserver(Observer* observer) {
-  observers_.AddObserver(observer);
-}
-
-void MaximizeModeController::RemoveObserver(Observer* observer) {
-  observers_.RemoveObserver(observer);
-}
-
 bool MaximizeModeController::CanEnterMaximizeMode() {
   // If we have ever seen accelerometer data, then HandleHingeRotation may
   // trigger maximize mode at some point in the future.
@@ -204,7 +179,9 @@ void MaximizeModeController::Shutdown() {
 
 void MaximizeModeController::OnAccelerometerUpdated(
     const ui::AccelerometerUpdate& update) {
+#if defined(OS_CHROMEOS)
   bool first_accelerometer_update = !have_seen_accelerometer_data_;
+#endif  // OS_CHROMEOS
   have_seen_accelerometer_data_ = true;
 
   // Ignore the reading if it appears unstable. The reading is considered
@@ -230,6 +207,7 @@ void MaximizeModeController::OnAccelerometerUpdated(
         update.get(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD),
         update.get(ui::ACCELEROMETER_SOURCE_SCREEN));
   }
+#if defined(OS_CHROMEOS)

[flackr, 2014/11/27 15:39:15]

There's a lot of "#if defined(OS_CHROMEOS)" going on here now. Can we make
screen rotation the responsibility of the increasingly inaccurately named
ScreenOrientationDelegate (I'd suggest renaming it ScreenOrientationController
with the responsibilities it would have with this suggestion).

We could have that class listen to the accelerometer updates and implement all
of the screen rotation. It could listen to when maximize mode starts/stops to
know when to start/stop freely rotating in response to accelerometer updates. I
think this would provide a cleaner separation of responsibilities.

[jonross, 2014/12/10 17:57:30]

Done.

   if (lid_stable)
     HandleScreenRotation(update.get(ui::ACCELEROMETER_SOURCE_SCREEN));
 
@@ -237,14 +215,20 @@ void MaximizeModeController::OnAccelerometerUpdated(
     // 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_);
+    Shell::GetInstance()->display_manager()->RegisterDisplayRotationProperties(
+        Shell::GetInstance()->screen_orientation_delegate()->rotation_locked(),
+        current_rotation_);
   }
+#endif  // OS_CHROMEOS
 }
 
+#if defined(OS_CHROMEOS)
 void MaximizeModeController::OnDisplayConfigurationChanged() {
-  if (ignore_display_configuration_updates_)
+  if (Shell::GetInstance()
+          ->screen_orientation_delegate()
+          ->ignore_display_configuration_updates()) {
     return;
+  }
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   gfx::Display::Rotation user_rotation = display_manager->
       GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
@@ -252,13 +236,13 @@ void MaximizeModeController::OnDisplayConfigurationChanged() {
     // 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);
+    Shell::GetInstance()->screen_orientation_delegate()->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)
@@ -333,19 +317,87 @@ void MaximizeModeController::HandleHingeRotation(const gfx::Vector3dF& base,
   }
 }
 
+void MaximizeModeController::EnterMaximizeMode() {
+  if (IsMaximizeModeWindowManagerEnabled())
+    return;
+  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
+  if (display_manager->HasInternalDisplay()) {
+    current_rotation_ = user_rotation_ =
+        display_manager->GetDisplayInfo(gfx::Display::InternalDisplayId())
+            .rotation();
+#if defined(OS_CHROMEOS)
+    LoadDisplayRotationProperties();
+#endif
+  }
+  EnableMaximizeModeWindowManager(true);
+#if defined(OS_CHROMEOS)
+  Shell::GetInstance()->display_controller()->AddObserver(this);
+#endif  // OS_CHROMEOS
+}
+
+void MaximizeModeController::LeaveMaximizeMode() {
+  if (!IsMaximizeModeWindowManagerEnabled())
+    return;
+#if defined(OS_CHROMEOS)
+  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
+  if (display_manager->HasInternalDisplay()) {
+    gfx::Display::Rotation current_rotation =
+        display_manager->GetDisplayInfo(gfx::Display::InternalDisplayId())
+            .rotation();
+    if (current_rotation != user_rotation_)
+      SetDisplayRotation(user_rotation_);
+  }
+  if (!shutting_down_) {
+    Shell::GetInstance()->screen_orientation_delegate()->SetRotationLocked(
+        false);
+  }
+  Shell::GetInstance()->display_controller()->RemoveObserver(this);
+#endif  // OS_CHROMEOS
+  EnableMaximizeModeWindowManager(false);
+}
+
+// Called after maximize mode has started, windows might still animate though.
+void MaximizeModeController::OnMaximizeModeStarted() {
+  RecordTouchViewStateTransition();
+}
+
+// Called after maximize mode has ended, windows might still be returning to
+// their original position.
+void MaximizeModeController::OnMaximizeModeEnded() {
+  RecordTouchViewStateTransition();
+}
+
+void MaximizeModeController::RecordTouchViewStateTransition() {
+  if (CanEnterMaximizeMode()) {
+    base::Time current_time = base::Time::Now();
+    base::TimeDelta delta = current_time - last_touchview_transition_time_;
+    if (IsMaximizeModeWindowManagerEnabled()) {
+      UMA_HISTOGRAM_LONG_TIMES("Ash.TouchView.TouchViewInactive", delta);
+      total_non_touchview_time_ += delta;
+    } else {
+      UMA_HISTOGRAM_LONG_TIMES("Ash.TouchView.TouchViewActive", delta);
+      total_touchview_time_ += delta;
+    }
+    last_touchview_transition_time_ = current_time;
+  }
+}
+
+#if defined(OS_CHROMEOS)
 void MaximizeModeController::HandleScreenRotation(const gfx::Vector3dF& lid) {
   bool maximize_mode_engaged = IsMaximizeModeWindowManagerEnabled();
 
   // TODO(jonross): track the updated rotation angle even when locked. So that
   // when rotation lock is removed the accelerometer rotation can be applied
   // without waiting for the next update.
-  if (!maximize_mode_engaged || rotation_locked_)
+  if (!maximize_mode_engaged ||
+      Shell::GetInstance()->screen_orientation_delegate()->rotation_locked())
     return;
 
-  DisplayManager* display_manager =
-      Shell::GetInstance()->display_manager();
-  gfx::Display::Rotation current_rotation = display_manager->GetDisplayInfo(
-      gfx::Display::InternalDisplayId()).rotation();
+  gfx::Display::Rotation current_rotation =
+      Shell::GetInstance()
+          ->display_manager()
+          ->GetDisplayInfo(gfx::Display::InternalDisplayId())
+          .rotation();
 
   // After determining maximize mode state, determine if the screen should
   // be rotated.
@@ -393,72 +445,14 @@ void MaximizeModeController::HandleScreenRotation(const gfx::Vector3dF& lid) {
     new_rotation = gfx::Display::ROTATE_180;
 
   if (new_rotation != current_rotation)
-    SetDisplayRotation(display_manager, new_rotation);
+    SetDisplayRotation(new_rotation);
 }
 
 void MaximizeModeController::SetDisplayRotation(
-    DisplayManager* display_manager,
     gfx::Display::Rotation rotation) {
-  base::AutoReset<bool> auto_ignore_display_configuration_updates(
-      &ignore_display_configuration_updates_, true);
   current_rotation_ = rotation;
-  display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
-                                      rotation);
-}
-
-void MaximizeModeController::EnterMaximizeMode() {
-  if (IsMaximizeModeWindowManagerEnabled())
-    return;
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  if (display_manager->HasInternalDisplay()) {
-    current_rotation_ = user_rotation_ = display_manager->
-        GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
-    LoadDisplayRotationProperties();
-  }
-  EnableMaximizeModeWindowManager(true);
-  Shell::GetInstance()->display_controller()->AddObserver(this);
-}
-
-void MaximizeModeController::LeaveMaximizeMode() {
-  if (!IsMaximizeModeWindowManagerEnabled())
-    return;
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  if (display_manager->HasInternalDisplay()) {
-    gfx::Display::Rotation current_rotation = display_manager->
-        GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
-    if (current_rotation != user_rotation_)
-      SetDisplayRotation(display_manager, user_rotation_);
-  }
-  if (!shutting_down_)
-    SetRotationLocked(false);
-  EnableMaximizeModeWindowManager(false);
-  Shell::GetInstance()->display_controller()->RemoveObserver(this);
-}
-
-// Called after maximize mode has started, windows might still animate though.
-void MaximizeModeController::OnMaximizeModeStarted() {
-  RecordTouchViewStateTransition();
-}
-
-// Called after maximize mode has ended, windows might still be returning to
-// their original position.
-void MaximizeModeController::OnMaximizeModeEnded() {
-  RecordTouchViewStateTransition();
-}
-
-void MaximizeModeController::RecordTouchViewStateTransition() {
-  if (CanEnterMaximizeMode()) {
-    base::Time current_time = base::Time::Now();
-    base::TimeDelta delta = current_time - last_touchview_transition_time_;
-    if (IsMaximizeModeWindowManagerEnabled()) {
-      UMA_HISTOGRAM_LONG_TIMES("Ash.TouchView.TouchViewInactive", delta);
-      total_non_touchview_time_ += delta;
-    } else {
-      UMA_HISTOGRAM_LONG_TIMES("Ash.TouchView.TouchViewActive", delta);
-      total_touchview_time_ += delta;
-    }
-    last_touchview_transition_time_ = current_time;
-  }
+  Shell::GetInstance()->screen_orientation_delegate()->SetDisplayRotation(
+      rotation);
 }
 
 void MaximizeModeController::LoadDisplayRotationProperties() {
@@ -466,10 +460,10 @@ void MaximizeModeController::LoadDisplayRotationProperties() {
   if (!display_manager->registered_internal_display_rotation_lock())
     return;
 
-  SetDisplayRotation(display_manager,
-                     display_manager->registered_internal_display_rotation());
-  SetRotationLocked(true);
+  SetDisplayRotation(display_manager->registered_internal_display_rotation());
+  Shell::GetInstance()->screen_orientation_delegate()->SetRotationLocked(true);
 }
+#endif  // OS_CHROMEOS
 
 void MaximizeModeController::OnAppTerminating() {
   if (CanEnterMaximizeMode()) {
@@ -487,7 +481,9 @@ void MaximizeModeController::OnAppTerminating() {
           100 * total_touchview_time_.InSeconds() / total_runtime.InSeconds());
     }
   }
+#if defined(OS_CHROMEOS)
   Shell::GetInstance()->display_controller()->RemoveObserver(this);
+#endif  // OS_CHROMEOS
 }
 
 bool MaximizeModeController::WasLidOpenedRecently() const {