Prevent DisplayPreferences from saving incorrect rotations.

ash/content/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/content/display/screen_orientation_controller_chromeos.h"
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
 #include "ash/rotator/screen_rotation_animator.h"
@@ skipping 27 matching lines @@
 
 blink::WebScreenOrientationLockType GetDisplayNaturalOrientation() {
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   if (!display_manager->HasInternalDisplay())
     return blink::WebScreenOrientationLockLandscape;
 
   ash::DisplayInfo info =
       display_manager->GetDisplayInfo(gfx::Display::InternalDisplayId());
   gfx::Size size = info.size_in_pixel();
-  switch (info.rotation()) {
+  switch (info.Rotation(gfx::Display::ROTATION_SOURCE_ACTIVE)) {
     case gfx::Display::ROTATE_0:
     case gfx::Display::ROTATE_180:
       return size.height() >= size.width()
                  ? blink::WebScreenOrientationLockPortrait
                  : blink::WebScreenOrientationLockLandscape;
     case gfx::Display::ROTATE_90:
     case gfx::Display::ROTATE_270:
       return size.height() < size.width()
                  ? blink::WebScreenOrientationLockPortrait
                  : blink::WebScreenOrientationLockLandscape;
@@ skipping 46 matching lines @@
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->HasInternalDisplay())
     return;
   base::AutoReset<bool> auto_ignore_display_configuration_updates(
       &ignore_display_configuration_updates_, true);
   display_manager->RegisterDisplayRotationProperties(rotation_locked_,
                                                      current_rotation_);
 }
 
 void ScreenOrientationController::SetDisplayRotation(
-    gfx::Display::Rotation rotation) {
+    gfx::Display::Rotation rotation,
+    gfx::Display::RotationSource source) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->HasInternalDisplay())
     return;
   current_rotation_ = rotation;
   base::AutoReset<bool> auto_ignore_display_configuration_updates(
       &ignore_display_configuration_updates_, true);
   ash::ScreenRotationAnimator(gfx::Display::InternalDisplayId())
-      .Rotate(rotation);
+      .Rotate(rotation, source);
 }
 
 void ScreenOrientationController::OnWindowActivated(aura::Window* gained_active,
                                                     aura::Window* lost_active) {
   ApplyLockForActiveWindow();
 }
 
 // Currently contents::WebContents will only be able to lock rotation while
 // fullscreen. In this state a user cannot click on the tab strip to change. If
 // this becomes supported for non-fullscreen tabs then the following interferes
@@ skipping 59 matching lines @@
   RemoveLockingWindow(requesting_window);
 }
 
 void ScreenOrientationController::OnDisplayConfigurationChanged() {
   if (ignore_display_configuration_updates_)
     return;
   gfx::Display::Rotation user_rotation =
       Shell::GetInstance()
           ->display_manager()
           ->GetDisplayInfo(gfx::Display::InternalDisplayId())
-          .rotation();
+          .Rotation(gfx::Display::ROTATION_SOURCE_ACTIVE);
   if (user_rotation != current_rotation_) {
     // 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);
     user_rotation_ = current_rotation_ = user_rotation;
   }
 }
 
 void ScreenOrientationController::OnMaximizeModeStarted() {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->HasInternalDisplay())
     return;
   current_rotation_ = user_rotation_ =
       display_manager->GetDisplayInfo(gfx::Display::InternalDisplayId())
-          .rotation();
+          .Rotation(gfx::Display::ROTATION_SOURCE_ACTIVE);
   if (!rotation_locked_)
     LoadDisplayRotationProperties();
   chromeos::AccelerometerReader::GetInstance()->AddObserver(this);
   Shell::GetInstance()->display_controller()->AddObserver(this);
 }
 
 void ScreenOrientationController::OnMaximizeModeEnded() {
   if (!Shell::GetInstance()->display_manager()->HasInternalDisplay())
     return;
   chromeos::AccelerometerReader::GetInstance()->RemoveObserver(this);
   Shell::GetInstance()->display_controller()->RemoveObserver(this);
   if (current_rotation_ != user_rotation_)
-    SetDisplayRotation(user_rotation_);
+    SetDisplayRotation(user_rotation_, gfx::Display::ROTATION_SOURCE_USER);
 }
 
 void ScreenOrientationController::LockRotation(
-    gfx::Display::Rotation rotation) {
+    gfx::Display::Rotation rotation,
+    gfx::Display::RotationSource source) {
   SetRotationLocked(true);
-  SetDisplayRotation(rotation);
+  SetDisplayRotation(rotation, source);
 }
 
 void ScreenOrientationController::LockRotationToOrientation(
     blink::WebScreenOrientationLockType lock_orientation) {
   rotation_locked_orientation_ = lock_orientation;
   switch (lock_orientation) {
     case blink::WebScreenOrientationLockAny:
       SetRotationLocked(false);
       break;
     case blink::WebScreenOrientationLockDefault:
@@ skipping 12 matching lines @@
       break;
     case blink::WebScreenOrientationLockLandscapeSecondary:
       LockRotationToSecondaryOrientation(
           blink::WebScreenOrientationLockLandscape);
       break;
     case blink::WebScreenOrientationLockLandscapePrimary:
       LockRotationToPrimaryOrientation(
           blink::WebScreenOrientationLockLandscape);
       break;
     case blink::WebScreenOrientationLockNatural:
-      LockRotation(gfx::Display::ROTATE_0);
+      LockRotation(gfx::Display::ROTATE_0,
+                   gfx::Display::ROTATION_SOURCE_ACTIVE);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void ScreenOrientationController::LockRotationToPrimaryOrientation(
     blink::WebScreenOrientationLockType lock_orientation) {
   LockRotation(natural_orientation_ == lock_orientation
                    ? gfx::Display::ROTATE_0
-                   : gfx::Display::ROTATE_90);
+                   : gfx::Display::ROTATE_90,
+               gfx::Display::ROTATION_SOURCE_ACTIVE);
 }
 
 void ScreenOrientationController::LockRotationToSecondaryOrientation(
     blink::WebScreenOrientationLockType lock_orientation) {
   LockRotation(natural_orientation_ == lock_orientation
                    ? gfx::Display::ROTATE_180
-                   : gfx::Display::ROTATE_270);
+                   : gfx::Display::ROTATE_270,
+               gfx::Display::ROTATION_SOURCE_ACTIVE);
 }
 
 void ScreenOrientationController::LockToRotationMatchingOrientation(
     blink::WebScreenOrientationLockType lock_orientation) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->HasInternalDisplay())
     return;
 
   gfx::Display::Rotation rotation =
       display_manager->GetDisplayInfo(gfx::Display::InternalDisplayId())
-          .rotation();
+          .Rotation(gfx::Display::ROTATION_SOURCE_ACTIVE);
   if (natural_orientation_ == lock_orientation) {
     if (rotation == gfx::Display::ROTATE_0 ||
         rotation == gfx::Display::ROTATE_180) {
       SetRotationLocked(true);
     } else {
-      LockRotation(gfx::Display::ROTATE_0);
+      LockRotation(gfx::Display::ROTATE_0,
+                   gfx::Display::ROTATION_SOURCE_ACTIVE);
     }
   } else {
     if (rotation == gfx::Display::ROTATE_90 ||
         rotation == gfx::Display::ROTATE_270) {
       SetRotationLocked(true);
     } else {
-      LockRotation(gfx::Display::ROTATE_90);
+      LockRotation(gfx::Display::ROTATE_90,
+                   gfx::Display::ROTATION_SOURCE_ACTIVE);
     }
   }
 }
 
 void ScreenOrientationController::HandleScreenRotation(
     const chromeos::AccelerometerReading& lid) {
   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.
@@ skipping 31 matching lines @@
   gfx::Display::Rotation new_rotation = gfx::Display::ROTATE_90;
   if (angle < 90.0f)
     new_rotation = gfx::Display::ROTATE_0;
   else if (angle < 180.0f)
     new_rotation = gfx::Display::ROTATE_270;
   else if (angle < 270.0f)
     new_rotation = gfx::Display::ROTATE_180;
 
   if (new_rotation != current_rotation_ &&
       IsRotationAllowedInLockedState(new_rotation))
-    SetDisplayRotation(new_rotation);
+    SetDisplayRotation(new_rotation,
+                       gfx::Display::ROTATION_SOURCE_ACCELEROMETER);
 }
 
 void ScreenOrientationController::LoadDisplayRotationProperties() {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->registered_internal_display_rotation_lock())
     return;
-  SetDisplayRotation(display_manager->registered_internal_display_rotation());
+  SetDisplayRotation(display_manager->registered_internal_display_rotation(),
+                     gfx::Display::ROTATION_SOURCE_ACCELEROMETER);
   SetRotationLocked(true);
 }
 
 void ScreenOrientationController::ApplyLockForActiveWindow() {
   aura::Window* active_window =
       Shell::GetInstance()->activation_client()->GetActiveWindow();
   for (auto const& windows : locking_windows_) {
     if (windows.first->TargetVisibility() &&
         active_window->Contains(windows.first)) {
       LockRotationToOrientation(windows.second);
@@ skipping 30 matching lines @@
 }
 
 bool ScreenOrientationController::CanRotateInLockedState() {
   return rotation_locked_orientation_ ==
              blink::WebScreenOrientationLockLandscape ||
          rotation_locked_orientation_ ==
              blink::WebScreenOrientationLockPortrait;
 }
 
 }  // namespace ash