mash: Partially migrate ScreenOrientationController to ash/common.

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/display/display_info.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm_shell.h"
+#include "ash/common/wm_window.h"
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/display_manager.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/aura/window.h"
-#include "ui/aura/window_observer.h"
 #include "ui/chromeos/accelerometer/accelerometer_util.h"
 #include "ui/display/display.h"
 #include "ui/gfx/geometry/size.h"
-#include "ui/wm/public/activation_client.h"
+
+namespace ash {
 
 namespace {
 
 // The angle which the screen has to be rotated past before the display will
 // rotate to match it (i.e. 45.0f is no stickiness).
 const float kDisplayRotationStickyAngleDegrees = 60.0f;
 
 // The minimum acceleration in m/s^2 in a direction required to trigger screen
 // rotation. This prevents rapid toggling of rotation when the device is near
 // flat and there is very little screen aligned force on it. The value is
 // effectively the sine of the rise angle required times the acceleration due
 // to gravity, with the current value requiring at least a 25 degree rise.
 const float kMinimumAccelerationScreenRotation = 4.2f;
 
 blink::WebScreenOrientationLockType GetDisplayNaturalOrientation() {
   if (!display::Display::HasInternalDisplay())
     return blink::WebScreenOrientationLockLandscape;
 
-  ash::DisplayInfo info =
-      ash::Shell::GetInstance()->display_manager()->GetDisplayInfo(
-          display::Display::InternalDisplayId());
+  DisplayInfo info =
+      WmShell::Get()->GetDisplayInfo(display::Display::InternalDisplayId());
   gfx::Size size = info.size_in_pixel();
   switch (info.GetActiveRotation()) {
     case display::Display::ROTATE_0:
     case display::Display::ROTATE_180:
       return size.height() >= size.width()
                  ? blink::WebScreenOrientationLockPortrait
                  : blink::WebScreenOrientationLockLandscape;
     case display::Display::ROTATE_90:
     case display::Display::ROTATE_270:
       return size.height() < size.width()
                  ? blink::WebScreenOrientationLockPortrait
                  : blink::WebScreenOrientationLockLandscape;
   }
   NOTREACHED();
   return blink::WebScreenOrientationLockLandscape;
 }
 
 }  // namespace
 
-namespace ash {
-
 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) {
   WmShell::Get()->AddShellObserver(this);
 }
 
 ScreenOrientationController::~ScreenOrientationController() {
   WmShell::Get()->RemoveShellObserver(this);
   chromeos::AccelerometerReader::GetInstance()->RemoveObserver(this);
-  Shell::GetInstance()->window_tree_host_manager()->RemoveObserver(this);
-  Shell::GetInstance()->activation_client()->RemoveObserver(this);
+  WmShell::Get()->RemoveDisplayObserver(this);
+  WmShell::Get()->RemoveActivationObserver(this);
   for (auto& windows : locking_windows_)
     windows.first->RemoveObserver(this);
 }
 
 void ScreenOrientationController::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ScreenOrientationController::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ScreenOrientationController::LockOrientationForWindow(
-    aura::Window* requesting_window,
+    WmWindow* requesting_window,
     blink::WebScreenOrientationLockType lock_orientation) {
   if (locking_windows_.empty())
-    Shell::GetInstance()->activation_client()->AddObserver(this);
+    WmShell::Get()->AddActivationObserver(this);
 
   if (!requesting_window->HasObserver(this))
     requesting_window->AddObserver(this);
   locking_windows_[requesting_window] = lock_orientation;
 
   ApplyLockForActiveWindow();
 }
 
-void ScreenOrientationController::UnlockOrientationForWindow(
-    aura::Window* window) {
+void ScreenOrientationController::UnlockOrientationForWindow(WmWindow* window) {
   locking_windows_.erase(window);
   if (locking_windows_.empty())
-    Shell::GetInstance()->activation_client()->RemoveObserver(this);
+    WmShell::Get()->RemoveActivationObserver(this);
   window->RemoveObserver(this);
   ApplyLockForActiveWindow();
 }
 
 void ScreenOrientationController::UnlockAll() {
   for (auto pair : locking_windows_)
     pair.first->RemoveObserver(this);
   locking_windows_.clear();
-  Shell::GetInstance()->activation_client()->RemoveObserver(this);
+  WmShell::Get()->RemoveActivationObserver(this);
   SetRotationLocked(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(
@@ skipping 23 matching lines @@
     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,
       true /* user_action */);
 }
 
-void ScreenOrientationController::OnWindowActivated(
-    aura::client::ActivationChangeObserver::ActivationReason reason,
-    aura::Window* gained_active,
-    aura::Window* lost_active) {
+void ScreenOrientationController::OnWindowActivated(WmWindow* gained_active,
+                                                    WmWindow* lost_active) {
   ApplyLockForActiveWindow();
 }
 
+void ScreenOrientationController::OnWindowDestroying(WmWindow* window) {
+  UnlockOrientationForWindow(window);
+}
+
 // 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
 // with TabDragController. OnWindowVisibilityChanged is called between a mouse
 // down and mouse up. The rotation this triggers leads to a coordinate space
 // change in the middle of an event. Causes the tab to separate from the tab
 // strip.
-void ScreenOrientationController::OnWindowVisibilityChanged(
-    aura::Window* window,
-    bool visible) {
+void ScreenOrientationController::OnWindowVisibilityChanged(WmWindow* window,
+                                                            bool visible) {
   if (locking_windows_.find(window) == locking_windows_.end())
     return;
   ApplyLockForActiveWindow();
 }
 
-void ScreenOrientationController::OnWindowDestroying(aura::Window* window) {
-  UnlockOrientationForWindow(window);
-}
-
 void ScreenOrientationController::OnAccelerometerUpdated(
     scoped_refptr<const chromeos::AccelerometerUpdate> update) {
   if (rotation_locked_ && !CanRotateInLockedState())
     return;
   if (!update->has(chromeos::ACCELEROMETER_SOURCE_SCREEN))
     return;
   // Ignore the reading if it appears unstable. The reading is considered
   // unstable if it deviates too much from gravity
   if (ui::IsAccelerometerReadingStable(*update,
                                        chromeos::ACCELEROMETER_SOURCE_SCREEN)) {
     HandleScreenRotation(update->get(chromeos::ACCELEROMETER_SOURCE_SCREEN));
   }
 }
 
 void ScreenOrientationController::OnDisplayConfigurationChanged() {
   if (ignore_display_configuration_updates_)
     return;
   if (!display::Display::HasInternalDisplay())
     return;
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   display::Display::Rotation user_rotation =
-      display_manager->GetDisplayInfo(display::Display::InternalDisplayId())
+      WmShell::Get()
+          ->GetDisplayInfo(display::Display::InternalDisplayId())
           .GetActiveRotation();
   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() {
   // 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_ =
-        Shell::GetInstance()
-            ->display_manager()
+        WmShell::Get()
             ->GetDisplayInfo(display::Display::InternalDisplayId())
             .GetActiveRotation();
   }
   if (!rotation_locked_)
     LoadDisplayRotationProperties();
   chromeos::AccelerometerReader::GetInstance()->AddObserver(this);
-  Shell::GetInstance()->window_tree_host_manager()->AddObserver(this);
+  WmShell::Get()->AddDisplayObserver(this);
 }
 
 void ScreenOrientationController::OnMaximizeModeEnded() {
   chromeos::AccelerometerReader::GetInstance()->RemoveObserver(this);
-  Shell::GetInstance()->window_tree_host_manager()->RemoveObserver(this);
+  WmShell::Get()->RemoveDisplayObserver(this);
   if (current_rotation_ != user_rotation_)
     SetDisplayRotation(user_rotation_, display::Display::ROTATION_SOURCE_USER);
 }
 
 void ScreenOrientationController::LockRotation(
     display::Display::Rotation rotation,
     display::Display::RotationSource source) {
   SetRotationLocked(true);
   SetDisplayRotation(rotation, source);
 }
@@ skipping 51 matching lines @@
                    ? display::Display::ROTATE_180
                    : display::Display::ROTATE_270,
                display::Display::ROTATION_SOURCE_ACTIVE);
 }
 
 void ScreenOrientationController::LockToRotationMatchingOrientation(
     blink::WebScreenOrientationLockType lock_orientation) {
   if (!display::Display::HasInternalDisplay())
     return;
 
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   display::Display::Rotation rotation =
-      display_manager->GetDisplayInfo(display::Display::InternalDisplayId())
+      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);
     } else {
       LockRotation(display::Display::ROTATE_0,
                    display::Display::ROTATION_SOURCE_ACTIVE);
     }
   } else {
@@ skipping 62 matching lines @@
 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(),
                      display::Display::ROTATION_SOURCE_ACCELEROMETER);
   SetRotationLocked(true);
 }
 
 void ScreenOrientationController::ApplyLockForActiveWindow() {
-  aura::Window* active_window =
-      Shell::GetInstance()->activation_client()->GetActiveWindow();
+  WmWindow* active_window = WmShell::Get()->GetActiveWindow();
   if (active_window) {
     for (auto const& windows : locking_windows_) {
-      if (windows.first->TargetVisibility() &&
+      if (windows.first->GetTargetVisibility() &&
           active_window->Contains(windows.first)) {
         LockRotationToOrientation(windows.second);
         return;
       }
     }
   }
   SetRotationLocked(false);
 }
 
 bool ScreenOrientationController::IsRotationAllowedInLockedState(
@@ skipping 15 matching lines @@
 }
 
 bool ScreenOrientationController::CanRotateInLockedState() {
   return rotation_locked_orientation_ ==
              blink::WebScreenOrientationLockLandscape ||
          rotation_locked_orientation_ ==
              blink::WebScreenOrientationLockPortrait;
 }
 
 }  // namespace ash