Lock Rotation on user settings changes

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"
@@ skipping 127 matching lines @@
       have_seen_accelerometer_data_(false),
       in_set_screen_rotation_(false),
       user_rotation_(gfx::Display::ROTATE_0) {
   Shell::GetInstance()->accelerometer_controller()->AddObserver(this);
 }
 
 MaximizeModeController::~MaximizeModeController() {
   Shell::GetInstance()->accelerometer_controller()->RemoveObserver(this);
 }
 
+void MaximizeModeController::SetRotationLocked(bool rotation_locked) {
+  if (rotation_locked_ == rotation_locked)
+    return;
+  rotation_locked_ = rotation_locked;
+  FOR_EACH_OBSERVER(Observer, observers_, OnRotationLockChanged());
+}
+
+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.
   // The --enable-touch-view-testing switch can also mean that we may enter
   // maximize mode.
   return have_seen_accelerometer_data_ ||
          CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kAshEnableTouchViewTesting);
 }
 
@@ skipping 12 matching lines @@
       std::abs(lid_magnitude - 1.0f) > kDeviationFromGravityThreshold) {
       return;
   }
 
   // Responding to the hinge rotation can change the maximize mode state which
   // affects screen rotation, so we handle hinge rotation first.
   HandleHingeRotation(base, lid);
   HandleScreenRotation(lid);
 }
 
+void MaximizeModeController::OnDisplayConfigurationChanged() {
+  if (rotation_locked_ || in_set_screen_rotation_)
+    return;
+  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
+  user_rotation_ = display_manager->

[flackr, 2014/05/28 14:48:04]

Updating the user_rotation_ might be an unexpected consequence if it actually
isn't different than the current_rotation_. I think I'd prefer to only update
this if it's not current_rotation_ so that resolution changes or other things
don't change the exit rotation.

[jonross, 2014/05/28 19:13:33]

Done.

+      GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
+  if (user_rotation_ != current_rotation_)

[flackr, 2014/05/28 14:48:04]

nit: It would be helpful to have a comment here. Presumably this is because the
user may have changed any display configuration, not just the rotation so we
only lock if rotation changes.

[jonross, 2014/05/28 19:13:33]

Done.

+    SetRotationLocked(true);
+}
+
 void MaximizeModeController::HandleHingeRotation(const gfx::Vector3dF& base,
                                                  const gfx::Vector3dF& lid) {
   static const gfx::Vector3dF hinge_vector(0.0f, 1.0f, 0.0f);
   bool maximize_mode_engaged =
       Shell::GetInstance()->IsMaximizeModeWindowManagerEnabled();
   // Ignore the component of acceleration parallel to the hinge for the purposes
   // of hinge angle calculation.
   gfx::Vector3dF base_flattened(base);
   gfx::Vector3dF lid_flattened(lid);
   base_flattened.set_y(0.0f);
@@ skipping 22 matching lines @@
   } else if (!maximize_mode_engaged &&
       angle > kEnterMaximizeModeAngle) {
     EnterMaximizeMode();
   }
 }
 
 void MaximizeModeController::HandleScreenRotation(const gfx::Vector3dF& lid) {
   bool maximize_mode_engaged =
       Shell::GetInstance()->IsMaximizeModeWindowManagerEnabled();
 
   if (!maximize_mode_engaged || rotation_locked_)

[flackr, 2014/05/28 14:48:04]

It might be useful to track accelerometer rotation even if the screen is locked
so that on unlocking the rotation can be immediately updated. Not that important
though since it will be updated soon, maybe just a TODO?

[jonross, 2014/05/28 19:13:33]

Added todo

     return;
 
   DisplayManager* display_manager =
       Shell::GetInstance()->display_manager();
   gfx::Display::Rotation current_rotation = display_manager->GetDisplayInfo(
       gfx::Display::InternalDisplayId()).rotation();

[flackr, 2014/05/28 14:48:04]

This might be a local variable now. current_rotation_ maybe?

[jonross, 2014/05/28 19:13:33]

This can be switched when we address the todo for line 247.

 
   // After determining maximize mode state, determine if the screen should
   // be rotated.
   gfx::Vector3dF lid_flattened(lid.x(), lid.y(), 0.0f);
   float lid_flattened_length = lid_flattened.Length();
   // When the lid is close to being flat, don't change rotation as it is too
   // sensitive to slight movements.
   if (lid_flattened_length < kMinimumAccelerationScreenRotation)
     return;
 
@@ skipping 35 matching lines @@
 
   if (new_rotation != current_rotation)
     SetDisplayRotation(display_manager, new_rotation);
 }
 
 void MaximizeModeController::SetDisplayRotation(
     DisplayManager* display_manager,
     gfx::Display::Rotation rotation) {
   base::AutoReset<bool> auto_in_set_screen_rotation(
       &in_set_screen_rotation_, true);
+  current_rotation_ = rotation;
   display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
                                       rotation);
 }
 
 void MaximizeModeController::EnterMaximizeMode() {
-  // TODO(jonross): Listen for display configuration changes. If the user
-  // causes a rotation change a rotation lock should be applied.
-  // https://crbug.com/369505
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   user_rotation_ = display_manager->

[flackr, 2014/05/28 14:48:04]

nit: Just use current_rotation_ = user_rotation_ = display_manager->...

[jonross, 2014/05/28 19:13:33]

Done.

       GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
+  current_rotation_ = user_rotation_;
   Shell::GetInstance()->EnableMaximizeModeWindowManager(true);
   event_blocker_.reset(new MaximizeModeEventBlocker);
 #if defined(OS_CHROMEOS)
   event_handler_.reset(new ScreenshotActionHandler);
 #endif
+  Shell::GetInstance()->display_controller()->AddObserver(this);
 }
 
 void MaximizeModeController::LeaveMaximizeMode() {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  DisplayInfo info = display_manager->
-      GetDisplayInfo(gfx::Display::InternalDisplayId());
-  gfx::Display::Rotation current_rotation = info.rotation();
+  gfx::Display::Rotation current_rotation = display_manager->
+      GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
   if (current_rotation != user_rotation_)
     SetDisplayRotation(display_manager, user_rotation_);
   rotation_locked_ = false;
   Shell::GetInstance()->EnableMaximizeModeWindowManager(false);
   event_blocker_.reset();
   event_handler_.reset();
+  Shell::GetInstance()->display_controller()->RemoveObserver(this);
 }
 
 }  // namespace ash