User orientation lock

ash/display/screen_orientation_controller_chromeos.h

 // 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.
 
 #ifndef ASH_DISPLAY_SCREEN_ORIENTATION_CONTROLLER_CHROMEOS_H_
 #define ASH_DISPLAY_SCREEN_ORIENTATION_CONTROLLER_CHROMEOS_H_
 
 #include <map>
 
 #include "ash/ash_export.h"
 #include "ash/common/shell_observer.h"
 #include "ash/common/wm_display_observer.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "chromeos/accelerometer/accelerometer_reader.h"
 #include "chromeos/accelerometer/accelerometer_types.h"
 #include "third_party/WebKit/public/platform/modules/screen_orientation/WebScreenOrientationLockType.h"
 #include "ui/aura/window_observer.h"
 #include "ui/display/display.h"
 #include "ui/wm/public/activation_change_observer.h"
 
 namespace ash {
+namespace test {
+class ScreenOrientationControllerTestApi;
+}
 
 // Implements ChromeOS specific functionality for ScreenOrientationProvider.
 class ASH_EXPORT ScreenOrientationController
     : public aura::client::ActivationChangeObserver,
       public aura::WindowObserver,
       public chromeos::AccelerometerReader::Observer,
       public WmDisplayObserver,
       public ShellObserver {
  public:
   // Observer that reports changes to the state of ScreenOrientationProvider's
   // rotation lock.
   class Observer {
    public:
-    // Invoked when rotation is locked or unlocked.
-    virtual void OnRotationLockChanged(bool rotation_locked) {}
+    // Invoked when rotation is locked or unlocked by a user.
+    virtual void OnUserRotationLockChanged() {}
 
    protected:
     virtual ~Observer() {}
   };
 
   ScreenOrientationController();
   ~ScreenOrientationController() override;
 
   // Add/Remove observers.
   void AddObserver(Observer* observer);
@@ skipping 11 matching lines @@
   bool ScreenOrientationProviderSupported() const;
 
   bool ignore_display_configuration_updates() const {
     return ignore_display_configuration_updates_;
   }
 
   // True if |rotation_lock_| has been set and accelerometer updates should not
   // rotate the display.
   bool rotation_locked() const { return rotation_locked_; }
 
-  // If |rotation_locked| future accelerometer updates should not change the
-  // display rotation.
-  void SetRotationLocked(bool rotation_locked);
+  bool user_rotation_locked() const {
+    return user_locked_orientation_ != blink::WebScreenOrientationLockAny;
+  }
 
-  // Sets the display rotation for the given |source|. The new |rotation| will
-  // also become active. Display changed notifications are surpressed for this
-  // change.
-  void SetDisplayRotation(display::Display::Rotation rotation,
-                          display::Display::RotationSource source);
+  // Trun on/off the user rotation lock. When turned on, it will lock
+  // the orientation to the current orientation.
+  // |user_rotation_locked()| method returns the current state of the
+  // user rotation lock.
+  void ToggleUserRotationLock();

[oshima, 2017/03/21 07:11:53]

I'm using toggle instead of SetUserRotationLock to avoid dealing with the
condition whether or not the true->true should update the orientation. Let me
know if you prefer SetXxx.

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

Using Toggle does make the unit testing harder to follow.

For the true->true transition, do we expect that to ever occur? TrayRotationLock
currently just flips the state.

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

No it will never happen as UI is toggle. Passing bool makes the semantics
a bit vague. Should we ignore true->true (which is sufficient for production),
or should we update it to the current orientation.

It's not hard to implement, but if we do, then question is if we need to test.

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

Well true->true might also end up being a confusing concept for a user if we
hooked that up. So I would support ignoring it.

I'm fine with the toggle semantics.

 
   // aura::client::ActivationChangeObserver:
   void OnWindowActivated(ActivationReason reason,
                          aura::Window* gained_active,
                          aura::Window* lost_active) override;
 
   // aura::WindowObserver:
   void OnWindowDestroying(aura::Window* window) override;
   void OnWindowVisibilityChanged(aura::Window* window, bool visible) override;
 
   // chromeos::AccelerometerReader::Observer:
   void OnAccelerometerUpdated(
       scoped_refptr<const chromeos::AccelerometerUpdate> update) override;
 
   // WmDisplayObserver:
   void OnDisplayConfigurationChanged() override;
 
   // ShellObserver:
   void OnMaximizeModeStarted() override;
   void OnMaximizeModeEnded() override;
 
  private:
+  friend class test::ScreenOrientationControllerTestApi;
+
+  // Sets the display rotation for the given |source|. The new |rotation| will
+  // also become active. Display changed notifications are surpressed for this
+  // change.
+  void SetDisplayRotation(display::Display::Rotation rotation,
+                          display::Display::RotationSource source);
+
+  void SetRotationLockedInternal(bool rotation_locked);
+
   // Sets the display rotation to |rotation|. Future accelerometer updates
   // should not be used to change the rotation. SetRotationLocked(false) removes
   // the rotation lock.
   void LockRotation(display::Display::Rotation rotation,
                     display::Display::RotationSource source);
 
   // Sets the display rotation based on |lock_orientation|. Future accelerometer
   // updates should not be used to change the rotation. SetRotationLocked(false)
   // removes the rotation lock.
   void LockRotationToOrientation(
@@ skipping 49 matching lines @@
   // When true then accelerometer updates should not rotate the display.
   bool rotation_locked_;
 
   // The orientation to which the current |rotation_locked_| was applied.
   blink::WebScreenOrientationLockType rotation_locked_orientation_;
 
   // The rotation of the display set by the user. This rotation will be
   // restored upon exiting maximize mode.
   display::Display::Rotation user_rotation_;
 
+  // The orientation of the device locked by the user.
+  blink::WebScreenOrientationLockType user_locked_orientation_ =
+      blink::WebScreenOrientationLockAny;
+
   // The current rotation set by ScreenOrientationController for the internal
   // display.
   display::Display::Rotation current_rotation_;
 
   // Rotation Lock observers.
   base::ObserverList<Observer> observers_;
 
   // Tracks all windows that have requested a lock, as well as the requested
   // orientation.
   std::map<WmWindow*, blink::WebScreenOrientationLockType> locking_windows_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenOrientationController);
 };
 
 }  // namespace ash
 
 #endif  // ASH_DISPLAY_SCREEN_ORIENTATION_CONTROLLER_CHROMEOS_H_