Resolve current orientation after applying the previous orientation request.

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 <unordered_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"
@@ skipping 24 matching lines @@
     virtual ~Observer() {}
   };
 
   ScreenOrientationController();
   ~ScreenOrientationController() override;
 
   // Add/Remove observers.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
-  // Allows/unallows a window to lock the screen orientation.
+  // Allows/unallows a window to lock the screen orientation.  When
+  // |lock_to_current| is true, it will take another stop to lock to
+  // the exact orientation locked by |lock_orientation|. For example,
+  // specifying PORTRAIT may still rotate to PORTRAIT_PRIMARY or
+  // PORTRAIT_SEONDARY. Setting true with PORTRAIT will lock to these
+  // specific orientation so that it will not rotate after it is
+  // locked to one of them.
   void LockOrientationForWindow(
       WmWindow* requesting_window,
-      blink::WebScreenOrientationLockType lock_orientation);
+      blink::WebScreenOrientationLockType lock_orientation,
+      bool lock_to_current);

[jonross, 2017/04/04 21:51:32]

So there is a split now in functionality between blink and arc for locks.

I wonder if it would make sense to have the resolution being done in
ArcAppWindowLauncherController here instead? One api for web, which doesn't have
this additional lock restriction. One for arc which can then apply it at window
activation?

If not, the nomenclature is slightly confusing. It makes me think that the lock
will be done immediately, vs waiting for activation. Especially with call sites
all documenting the purpose of the boolean.

Maybe an enum? Since this is more of a narrowing of the orientation request.
  RestrictOrientation {
    None,
    ToOrientationAtActivation
  }

[oshima, 2017/04/04 23:00:25]

Well, it's already different (for example, blink can lock only in fullscreen in
tablet mode,
while arc always can request orientation, and it'll be honored when switching to
tablet).
Note that it will not change the blink behavior.

There are lock concept that does not exit in html5 orientation spec. This is
ASH/ChromeOS,
so I don't think that's going to be an issue as long as we can cover both.
The lock is determined when locked, so we can't implement there unless we add a
callback
when lock applied, which is IMO overkill.
Note that we always lock at activation, with or without this change. 
This is to lock to specific orientation after actually lock happened. So it's
more like

{
   Normal,
   ToFurtherLockToSpecificOrientation
}
or
{
  Normal,
  DisableSensorRotationAfterLock
}

maybe latter is easier to understand? WDYT?

[jonross, 2017/04/04 23:49:25]

Good point, I'm fine keeping this through the one api then.

 
Yeah that would be overkill, keeping it in its current implementation location
SGTM.
Yeah the latter is easier to understand. Can we switch to using that?

[oshima, 2017/04/05 18:19:30]

Done.

   void UnlockOrientationForWindow(WmWindow* window);
 
   // Unlock all and set the rotation back to the user specified rotation.
   void UnlockAll();
 
   bool ScreenOrientationProviderSupported() const;
 
   bool ignore_display_configuration_updates() const {
     return ignore_display_configuration_updates_;
   }
@@ skipping 31 matching lines @@
   // WmDisplayObserver:
   void OnDisplayConfigurationChanged() override;
 
   // ShellObserver:
   void OnMaximizeModeStarted() override;
   void OnMaximizeModeEnded() override;
 
  private:
   friend class test::ScreenOrientationControllerTestApi;
 
+  struct LockInfo {
+    LockInfo() {}
+    LockInfo(blink::WebScreenOrientationLockType orientation,
+             bool lock_to_current)
+        : orientation(orientation), lock_to_current(lock_to_current) {}
+
+    blink::WebScreenOrientationLockType orientation =
+        blink::WebScreenOrientationLockAny;
+    bool lock_to_current = false;
+  };
+
   // 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);
 
   // A helper method that set locked to the given |orientation| and save it.
   void SetLockToOrientation(blink::WebScreenOrientationLockType orientation);
@@ skipping 38 matching lines @@
   // window, and applies it. If there is none, rotation lock will be removed.
   void ApplyLockForActiveWindow();
 
   // Both |blink::WebScreenOrientationLockLandscape| and
   // |blink::WebScreenOrientationLockPortrait| allow for rotation between the
   // two angles of the same screen orientation
   // (http://www.w3.org/TR/screen-orientation/). Returns true if |rotation| is
   // supported for the current |rotation_locked_orientation_|.
   bool IsRotationAllowedInLockedState(display::Display::Rotation rotation);
 
+  blink::WebScreenOrientationLockType GetCurrentOrientationForTest() const;
+
   // Certain orientation locks allow for rotation between the two angles of the
   // same screen orientation. Returns true if |rotation_locked_orientation_|
   // allows rotation.
   bool CanRotateInLockedState();
 
   // The orientation of the display when at a rotation of 0.
   blink::WebScreenOrientationLockType natural_orientation_;
 
   // True when changes being applied cause OnDisplayConfigurationChanged() to be
   // called, and for which these changes should be ignored.
@@ skipping 15 matching lines @@
 
   // 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_;
+  std::unordered_map<WmWindow*, LockInfo> lock_info_map_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenOrientationController);
 };
 
 }  // namespace ash
 
 #endif  // ASH_DISPLAY_SCREEN_ORIENTATION_CONTROLLER_CHROMEOS_H_