Remember User locked rotation

ash/display/screen_orientation_controller_chromeos.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/display/screen_orientation_controller_chromeos.h"
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/window_state.h"
@@ skipping 44 matching lines @@
     case display::Display::ROTATE_90:
     case display::Display::ROTATE_270:
       return size.height() < size.width()
                  ? blink::WebScreenOrientationLockPortrait
                  : blink::WebScreenOrientationLockLandscape;
   }
   NOTREACHED();
   return blink::WebScreenOrientationLockLandscape;
 }
 
+blink::WebScreenOrientationLockType RotationToOrientation(
+    display::Display::Rotation rotation) {
+  blink::WebScreenOrientationLockType natural = GetDisplayNaturalOrientation();
+  if (natural == blink::WebScreenOrientationLockLandscape) {
+    switch (rotation) {
+      case display::Display::ROTATE_0:
+        return blink::WebScreenOrientationLockLandscapePrimary;
+      case display::Display::ROTATE_90:
+        return blink::WebScreenOrientationLockPortraitPrimary;
+      case display::Display::ROTATE_180:
+        return blink::WebScreenOrientationLockLandscapeSecondary;
+      case display::Display::ROTATE_270:
+        return blink::WebScreenOrientationLockPortraitSecondary;
+    }
+  } else {  // Natural portrait
+    switch (rotation) {
+      case display::Display::ROTATE_0:
+        return blink::WebScreenOrientationLockPortraitPrimary;
+      case display::Display::ROTATE_90:
+        return blink::WebScreenOrientationLockLandscapePrimary;
+      case display::Display::ROTATE_180:
+        return blink::WebScreenOrientationLockPortraitSecondary;
+      case display::Display::ROTATE_270:
+        return blink::WebScreenOrientationLockLandscapeSecondary;
+    }
+  }
+  NOTREACHED();
+  return blink::WebScreenOrientationLockAny;
+}
+
+// Returns the rotation that matches the orientation type.
+// Returns ROTATE_0 if the given orientation is ANY, which is used
+// to indicate that user didn't lock orientation.
+display::Display::Rotation OrientationToRotation(
+    blink::WebScreenOrientationLockType orientation) {
+  blink::WebScreenOrientationLockType natural = GetDisplayNaturalOrientation();
+  if (orientation == blink::WebScreenOrientationLockAny) {
+    return display::Display::ROTATE_0;
+  }
+
+  if (natural == blink::WebScreenOrientationLockLandscape) {
+    switch (orientation) {
+      case blink::WebScreenOrientationLockLandscapePrimary:
+        return display::Display::ROTATE_0;
+      case blink::WebScreenOrientationLockPortraitPrimary:
+        return display::Display::ROTATE_90;
+      case blink::WebScreenOrientationLockLandscapeSecondary:
+        return display::Display::ROTATE_180;
+      case blink::WebScreenOrientationLockPortraitSecondary:
+        return display::Display::ROTATE_270;
+      default:
+        break;
+    }
+  } else {  // Natural portrait
+    switch (orientation) {
+      case blink::WebScreenOrientationLockPortraitPrimary:
+        return display::Display::ROTATE_0;
+      case blink::WebScreenOrientationLockLandscapePrimary:
+        return display::Display::ROTATE_90;
+      case blink::WebScreenOrientationLockPortraitSecondary:
+        return display::Display::ROTATE_180;
+      case blink::WebScreenOrientationLockLandscapeSecondary:
+        return display::Display::ROTATE_270;
+      default:
+        break;
+    }
+  }
+  NOTREACHED() << orientation;
+  return display::Display::ROTATE_0;
+}
+
+// Returns the locked orientation that matches the application
+// requested orientation, or the application orientation itself
+// if it didn't match.
+blink::WebScreenOrientationLockType ResolveOrientationLock(
+    blink::WebScreenOrientationLockType app_requested,
+    blink::WebScreenOrientationLockType lock) {
+  if (app_requested == blink::WebScreenOrientationLockAny ||
+      (app_requested == blink::WebScreenOrientationLockLandscape &&
+       (lock == blink::WebScreenOrientationLockLandscapePrimary ||
+        lock == blink::WebScreenOrientationLockLandscapeSecondary)) ||
+      (app_requested == blink::WebScreenOrientationLockPortrait &&
+       (lock == blink::WebScreenOrientationLockPortraitPrimary ||
+        lock == blink::WebScreenOrientationLockPortraitSecondary))) {
+    return lock;
+  }
+  return app_requested;
+}
+
 }  // namespace
 
 ScreenOrientationController::ScreenOrientationController()
     : natural_orientation_(GetDisplayNaturalOrientation()),
       ignore_display_configuration_updates_(false),
       rotation_locked_(false),
       rotation_locked_orientation_(blink::WebScreenOrientationLockAny),
       user_rotation_(display::Display::ROTATE_0),
       current_rotation_(display::Display::ROTATE_0) {
   Shell::GetInstance()->AddShellObserver(this);
@@ skipping 49 matching lines @@
 
 bool ScreenOrientationController::ScreenOrientationProviderSupported() const {
   return Shell::Get()
              ->maximize_mode_controller()
              ->IsMaximizeModeWindowManagerEnabled() &&
          !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kAshDisableScreenOrientationLock);
 }
 
 void ScreenOrientationController::ToggleUserRotationLock() {
+  if (!display::Display::HasInternalDisplay())
+    return;
+
   if (user_rotation_locked()) {
     user_locked_orientation_ = blink::WebScreenOrientationLockAny;
   } else {
     display::Display::Rotation current_rotation =
         WmShell::Get()
             ->GetDisplayInfo(display::Display::InternalDisplayId())
             .GetActiveRotation();
-    blink::WebScreenOrientationLockType natural =
-        GetDisplayNaturalOrientation();
-    if (natural == blink::WebScreenOrientationLockLandscape) {
-      switch (current_rotation) {
-        case display::Display::ROTATE_0:
-          user_locked_orientation_ =
-              blink::WebScreenOrientationLockLandscapePrimary;
-          break;
-        case display::Display::ROTATE_90:
-          user_locked_orientation_ =
-              blink::WebScreenOrientationLockPortraitPrimary;
-          break;
-        case display::Display::ROTATE_180:
-          user_locked_orientation_ =
-              blink::WebScreenOrientationLockLandscapeSecondary;
-          break;
-        case display::Display::ROTATE_270:
-          user_locked_orientation_ =
-              blink::WebScreenOrientationLockPortraitSecondary;
-          break;
-      }
-    } else {  // Natural portrait
-      switch (current_rotation) {
-        case display::Display::ROTATE_0:
-          user_locked_orientation_ =
-              blink::WebScreenOrientationLockPortraitPrimary;
-          break;
-        case display::Display::ROTATE_90:
-          user_locked_orientation_ =
-              blink::WebScreenOrientationLockLandscapePrimary;
-          break;
-        case display::Display::ROTATE_180:
-          user_locked_orientation_ =
-              blink::WebScreenOrientationLockPortraitSecondary;
-          break;
-        case display::Display::ROTATE_270:
-          user_locked_orientation_ =
-              blink::WebScreenOrientationLockLandscapeSecondary;
-          break;
-      }
-    }
+    user_locked_orientation_ = RotationToOrientation(current_rotation);
   }
+  base::AutoReset<bool> auto_ignore_display_configuration_updates(
+      &ignore_display_configuration_updates_, true);
+  Shell::GetInstance()->display_manager()->RegisterDisplayRotationProperties(
+      user_rotation_locked(), OrientationToRotation(user_locked_orientation_));
+
   ApplyLockForActiveWindow();
 
   for (auto& observer : observers_)
     observer.OnUserRotationLockChanged();
 }
 
 void ScreenOrientationController::OnWindowActivated(ActivationReason reason,
                                                     aura::Window* gained_active,
                                                     aura::Window* lost_active) {
   ApplyLockForActiveWindow();
@@ skipping 60 matching lines @@
   if (display::Display::HasInternalDisplay()) {
     current_rotation_ = user_rotation_ =
         WmShell::Get()
             ->GetDisplayInfo(display::Display::InternalDisplayId())
             .GetActiveRotation();
   }
   if (!rotation_locked_)
     LoadDisplayRotationProperties();
   chromeos::AccelerometerReader::GetInstance()->AddObserver(this);
   WmShell::Get()->AddDisplayObserver(this);
+
+  ApplyLockForActiveWindow();
+  for (auto& observer : observers_)
+    observer.OnUserRotationLockChanged();

[jonross, 2017/03/24 15:21:04]

Do we want to send this if there was no rotation lock state change?

Such as no lock at all, and entering maximize mode leads to no lock?

[oshima, 2017/03/24 16:33:43]

no lock is still one of states, so I consider this is still a state change.
In clamshell, it's disabled, then it becomes one of any, portrait, secondary
landscape etc
upon entering the touch view mode.

Which means I we should do the same when exiting, so thanks for pointing this
out.

[jonross, 2017/03/24 16:46:49]

Okay that sgtm

 }
 
 void ScreenOrientationController::OnMaximizeModeEnded() {
   chromeos::AccelerometerReader::GetInstance()->RemoveObserver(this);
   WmShell::Get()->RemoveDisplayObserver(this);
   if (current_rotation_ != user_rotation_)
     SetDisplayRotation(user_rotation_, display::Display::ROTATION_SOURCE_USER);
 }
 
 void ScreenOrientationController::SetDisplayRotation(
     display::Display::Rotation rotation,
     display::Display::RotationSource source) {
   if (!display::Display::HasInternalDisplay())
     return;
   current_rotation_ = rotation;
   base::AutoReset<bool> auto_ignore_display_configuration_updates(
       &ignore_display_configuration_updates_, true);
 
   Shell::GetInstance()->display_configuration_controller()->SetDisplayRotation(
       display::Display::InternalDisplayId(), rotation, source);
 }
 
 void ScreenOrientationController::SetRotationLockedInternal(
     bool rotation_locked) {
   if (rotation_locked_ == rotation_locked)
     return;
   rotation_locked_ = rotation_locked;
   if (!rotation_locked_)
     rotation_locked_orientation_ = blink::WebScreenOrientationLockAny;
-  if (!display::Display::HasInternalDisplay())
-    return;
-  base::AutoReset<bool> auto_ignore_display_configuration_updates(
-      &ignore_display_configuration_updates_, true);
-  Shell::GetInstance()->display_manager()->RegisterDisplayRotationProperties(
-      rotation_locked_, current_rotation_);
 }
 
 void ScreenOrientationController::LockRotation(
     display::Display::Rotation rotation,
     display::Display::RotationSource source) {
   SetRotationLockedInternal(true);
   SetDisplayRotation(rotation, source);
 }
 
 void ScreenOrientationController::LockRotationToOrientation(
@@ skipping 129 matching lines @@
     SetDisplayRotation(new_rotation,
                        display::Display::ROTATION_SOURCE_ACCELEROMETER);
   }
 }
 
 void ScreenOrientationController::LoadDisplayRotationProperties() {
   display::DisplayManager* display_manager =
       Shell::GetInstance()->display_manager();
   if (!display_manager->registered_internal_display_rotation_lock())
     return;
-  SetDisplayRotation(display_manager->registered_internal_display_rotation(),
-                     display::Display::ROTATION_SOURCE_ACCELEROMETER);
-  SetRotationLockedInternal(true);
+  user_locked_orientation_ = RotationToOrientation(
+      display_manager->registered_internal_display_rotation());
 }
 
 void ScreenOrientationController::ApplyLockForActiveWindow() {
   MruWindowTracker::WindowList mru_windows(
       Shell::GetInstance()->mru_window_tracker()->BuildMruWindowList());
 
   for (WmWindow* window : mru_windows) {
     if (!window->GetTargetVisibility())
       continue;
-    // TODO(oshima): If the application's orientation is landscape
-    // and user_locked_orientation_ is landscape primary or secondary,
-    // it should lock to the specific orientation. (and same for portrait).
     for (auto const& pair : locking_windows_) {
       if (pair.first->GetTargetVisibility() && window->Contains(pair.first)) {
-        LockRotationToOrientation(pair.second ==
-                                          blink::WebScreenOrientationLockAny
-                                      ? user_locked_orientation_
-                                      : pair.second);
+        LockRotationToOrientation(
+            ResolveOrientationLock(pair.second, user_locked_orientation_));
         return;
       }
     }
     // The default orientation for all chrome browser/apps windows is
     // ANY, so use the user_locked_orientation_;
     if (window->GetTargetVisibility() &&
         static_cast<AppType>(window->GetAppType()) != AppType::OTHERS) {
       LockRotationToOrientation(user_locked_orientation_);
       return;
     }
@@ skipping 20 matching lines @@
 }
 
 bool ScreenOrientationController::CanRotateInLockedState() {
   return rotation_locked_orientation_ ==
              blink::WebScreenOrientationLockLandscape ||
          rotation_locked_orientation_ ==
              blink::WebScreenOrientationLockPortrait;
 }
 
 }  // namespace ash