User orientation lock

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"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/display/display_configuration_controller.h"
+#include "ash/shared/app_types.h"
 #include "ash/shell.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "chromeos/accelerometer/accelerometer_reader.h"
 #include "chromeos/accelerometer/accelerometer_types.h"
 #include "ui/chromeos/accelerometer/accelerometer_util.h"
 #include "ui/display/display.h"
 #include "ui/display/manager/display_manager.h"
 #include "ui/display/manager/managed_display_info.h"
 #include "ui/gfx/geometry/size.h"
@@ skipping 85 matching lines @@
     Shell::GetInstance()->activation_client()->RemoveObserver(this);
   window->aura_window()->RemoveObserver(this);
   ApplyLockForActiveWindow();
 }
 
 void ScreenOrientationController::UnlockAll() {
   for (auto pair : locking_windows_)
     pair.first->aura_window()->RemoveObserver(this);
   locking_windows_.clear();
   Shell::GetInstance()->activation_client()->RemoveObserver(this);
-  SetRotationLocked(false);
+  SetRotationLockedInternal(false);
   if (user_rotation_ != current_rotation_)
     SetDisplayRotation(user_rotation_, display::Display::ROTATION_SOURCE_USER);
 }
 
 bool ScreenOrientationController::ScreenOrientationProviderSupported() const {
   return WmShell::Get()
              ->maximize_mode_controller()
              ->IsMaximizeModeWindowManagerEnabled() &&
          !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kAshDisableScreenOrientationLock);
 }
 
-void ScreenOrientationController::SetRotationLocked(bool rotation_locked) {
-  if (rotation_locked_ == rotation_locked)
-    return;
-  rotation_locked_ = rotation_locked;
-  if (!rotation_locked_)
-    rotation_locked_orientation_ = blink::WebScreenOrientationLockAny;
+void ScreenOrientationController::ToggleUserRotationLock() {
+  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;
+      }
+    }
+  }
+  ApplyLockForActiveWindow();
+
   for (auto& observer : observers_)
-    observer.OnRotationLockChanged(rotation_locked_);
-  if (!display::Display::HasInternalDisplay())
-    return;
-  base::AutoReset<bool> auto_ignore_display_configuration_updates(
-      &ignore_display_configuration_updates_, true);
-  Shell::GetInstance()->display_manager()->RegisterDisplayRotationProperties(

[jonross, 2017/03/21 14:56:43]

Were you planning to land this in a follow up change?

[oshima, 2017/03/21 15:10:57]

Yes. I mentioned it in the CL description.
(note that the code was simply moved down below, so this still exists, but it
needs to be updated.)

[jonross, 2017/03/22 23:51:55]

SGTM

-      rotation_locked_, current_rotation_);
-}
-
-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);
+    observer.OnUserRotationLockChanged();
 }
 
 void ScreenOrientationController::OnWindowActivated(ActivationReason reason,
                                                     aura::Window* gained_active,
                                                     aura::Window* lost_active) {
   ApplyLockForActiveWindow();
 }
 
 void ScreenOrientationController::OnWindowDestroying(aura::Window* window) {
   UnlockOrientationForWindow(WmWindow::Get(window));
@@ skipping 31 matching lines @@
 void ScreenOrientationController::OnDisplayConfigurationChanged() {
   if (ignore_display_configuration_updates_)
     return;
   if (!display::Display::HasInternalDisplay())
     return;
   display::Display::Rotation user_rotation =
       WmShell::Get()
           ->GetDisplayInfo(display::Display::InternalDisplayId())
           .GetActiveRotation();
   if (user_rotation != current_rotation_) {
+    // TODO(oshima): We should disable the orientation change in settings
+    // because application may not work correctly.
+
     // 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);
+    SetRotationLockedInternal(true);

[jonross, 2017/03/21 14:56:43]

So currently we have been treating the settings app as a source of a user
rotation lock.

This change would bypass the updated user rotation lock logic. So they would not
be able to use the tray to toggle state.

Based on your TODO above you feel we should just disable this feature completely
in touchview? That would make sense for the internal display.

[oshima, 2017/03/21 15:10:57]

I'll make two changes:
- Disable the rotation change in settings as it's confusing (you shouldn't be
able to change the orientation
  when the app requested fixed orientation.
- We still can't prevent an app from calling chrome.system.display, so this will
be treated as
 a user requested rotation lock.

This will be addressed in the follow up CL.

[jonross, 2017/03/22 23:51:55]

SGTM

     user_rotation_ = current_rotation_ = user_rotation;
   }
 }
 
 void ScreenOrientationController::OnMaximizeModeStarted() {
   // Do not exit early, as the internal display can be determined after Maximize
   // Mode has started. (chrome-os-partner:38796)
   // Always start observing.
   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);
 }
 
 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) {
-  SetRotationLocked(true);
+  SetRotationLockedInternal(true);
   SetDisplayRotation(rotation, source);
 }
 
 void ScreenOrientationController::LockRotationToOrientation(
     blink::WebScreenOrientationLockType lock_orientation) {
   rotation_locked_orientation_ = lock_orientation;
   switch (lock_orientation) {
     case blink::WebScreenOrientationLockAny:
-      SetRotationLocked(false);
+      SetRotationLockedInternal(false);
       break;
     case blink::WebScreenOrientationLockDefault:
       NOTREACHED();
       break;
     case blink::WebScreenOrientationLockPortraitPrimary:
       LockRotationToPrimaryOrientation(blink::WebScreenOrientationLockPortrait);
       break;
     case blink::WebScreenOrientationLockLandscape:
     case blink::WebScreenOrientationLockPortrait:
       LockToRotationMatchingOrientation(lock_orientation);
@@ skipping 41 matching lines @@
   if (!display::Display::HasInternalDisplay())
     return;
 
   display::Display::Rotation rotation =
       WmShell::Get()
           ->GetDisplayInfo(display::Display::InternalDisplayId())
           .GetActiveRotation();
   if (natural_orientation_ == lock_orientation) {
     if (rotation == display::Display::ROTATE_0 ||
         rotation == display::Display::ROTATE_180) {
-      SetRotationLocked(true);
+      SetRotationLockedInternal(true);
     } else {
       LockRotation(display::Display::ROTATE_0,
                    display::Display::ROTATION_SOURCE_ACTIVE);
     }
   } else {
     if (rotation == display::Display::ROTATE_90 ||
         rotation == display::Display::ROTATE_270) {
-      SetRotationLocked(true);
+      SetRotationLockedInternal(true);
     } else {
       LockRotation(display::Display::ROTATE_90,
                    display::Display::ROTATION_SOURCE_ACTIVE);
     }
   }
 }
 
 void ScreenOrientationController::HandleScreenRotation(
     const chromeos::AccelerometerReading& lid) {
   gfx::Vector3dF lid_flattened(lid.x, lid.y, 0.0f);
@@ skipping 46 matching lines @@
   }
 }
 
 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);
-  SetRotationLocked(true);
+  SetRotationLockedInternal(true);
 }
 
 void ScreenOrientationController::ApplyLockForActiveWindow() {
-  WmWindow* active_window = WmShell::Get()->GetActiveWindow();
-  if (active_window) {
-    for (auto const& windows : locking_windows_) {
-      if (windows.first->GetTargetVisibility() &&
-          active_window->Contains(windows.first)) {
-        LockRotationToOrientation(windows.second);
+  MruWindowTracker::WindowList mru_windows(
+      WmShell::Get()->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_) {

[jonross, 2017/03/21 14:56:43]

The ARC++ app windows are being registered with locking_windows_?

[oshima, 2017/03/21 15:10:57]

Yes, ARC++ apps always set the orientation.

[jonross, 2017/03/22 23:51:55]

Good to know, I wasn't 100% which path the took. SGTM

+      if (pair.first->GetTargetVisibility() && window->Contains(pair.first)) {
+        LockRotationToOrientation(pair.second ==
+                                          blink::WebScreenOrientationLockAny
+                                      ? user_locked_orientation_
+                                      : pair.second);
         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;
+    }
   }
-  SetRotationLocked(false);
+  LockRotationToOrientation(user_locked_orientation_);
 }
 
 bool ScreenOrientationController::IsRotationAllowedInLockedState(
     display::Display::Rotation rotation) {
   if (!rotation_locked_)
     return true;
 
   if (!CanRotateInLockedState())
     return false;
 
   if (natural_orientation_ == rotation_locked_orientation_) {
     return rotation == display::Display::ROTATE_0 ||
            rotation == display::Display::ROTATE_180;
   } else {
     return rotation == display::Display::ROTATE_90 ||
            rotation == display::Display::ROTATE_270;
   }
   return false;
 }
 
 bool ScreenOrientationController::CanRotateInLockedState() {
   return rotation_locked_orientation_ ==
              blink::WebScreenOrientationLockLandscape ||
          rotation_locked_orientation_ ==
              blink::WebScreenOrientationLockPortrait;
 }
 
 }  // namespace ash