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 84 matching lines @@
     WmShell::Get()->RemoveActivationObserver(this);
   window->aura_window()->RemoveObserver(this);
   ApplyLockForActiveWindow();
 }
 
 void ScreenOrientationController::UnlockAll() {
   for (auto pair : locking_windows_)
     pair.first->aura_window()->RemoveObserver(this);
   locking_windows_.clear();
   WmShell::Get()->RemoveActivationObserver(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(
-      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(WmWindow* gained_active,
                                                     WmWindow* lost_active) {
   ApplyLockForActiveWindow();
 }
 
 void ScreenOrientationController::OnWindowDestroying(aura::Window* window) {
   UnlockOrientationForWindow(WmWindow::Get(window));
 }
@@ skipping 30 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);
     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_) {
+      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