Screen.orientation lock API implementation for Windows8 and later.

content/browser/screen_orientation/screen_orientation_delegate_win.cc

Index: content/browser/screen_orientation/screen_orientation_delegate_win.cc
diff --git a/content/browser/screen_orientation/screen_orientation_delegate_win.cc b/content/browser/screen_orientation/screen_orientation_delegate_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4997b649029669a6dfe003d4f8fe77c05979ae8a
--- /dev/null
+++ b/content/browser/screen_orientation/screen_orientation_delegate_win.cc
@@ -0,0 +1,129 @@
+// Copyright 2016 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 "content/browser/screen_orientation/screen_orientation_delegate_win.h"
+
+#include <windows.h>

[sky, 2016/03/04 23:37:36]

nit: newline between 7/8.

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

+#include "content/public/browser/screen_orientation_provider.h"
+
+namespace content {
+
+ScreenOrientationDelegateWin::ScreenOrientationDelegateWin() {
+  content::ScreenOrientationProvider::SetDelegate(this);

[mlamouri (slow - plz ping), 2016/03/05 00:39:14]

nit: no need for "content::"

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

+}
+
+ScreenOrientationDelegateWin::~ScreenOrientationDelegateWin() {
+  content::ScreenOrientationProvider::SetDelegate(nullptr);

[mlamouri (slow - plz ping), 2016/03/05 00:39:14]

ditto

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

+}
+
+bool ScreenOrientationDelegateWin::FullScreenRequired(
+    content::WebContents* web_contents) {

[mlamouri (slow - plz ping), 2016/03/05 00:39:14]

ditto (and probably some more below this)

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

+  return false;
+}
+
+// SetDisplayAutoRotationPreferences is available on Windows 8 and after.
+static void SetDisplayAutoRotationPreferencesWrapper(
+  ORIENTATION_PREFERENCE orientation) {

[sky, 2016/03/04 23:37:35]

nit: run git cl format as your formatting is off here.

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

+  typedef void(WINAPI *SetDisplayAutoRotationPreferencesPtr)(
+    ORIENTATION_PREFERENCE);
+  static SetDisplayAutoRotationPreferencesPtr
+    set_display_auto_rotation_preferences_func =
+      reinterpret_cast<SetDisplayAutoRotationPreferencesPtr>(
+        GetProcAddress(GetModuleHandleA("user32.dll"),
+                       "SetDisplayAutoRotationPreferences"));
+  if (set_display_auto_rotation_preferences_func)
+    set_display_auto_rotation_preferences_func(orientation);

[sky, 2016/03/04 23:37:36]

How come the docs for this say it takes a pointer?
https://msdn.microsoft.com/en-us/library/windows/desktop/dn629268(v=vs.85).aspx

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Documentation is wrong there. A place where is it correct:
https://msdn.microsoft.com/en-us/library/vs/alm/dn376361(v=vs.85).aspx

+}
+
+// GetAutoRotationState is available on Windows 8 and after.
+static BOOL GetAutoRotationStateWrapper(PAR_STATE pState) {

[sky, 2016/03/04 23:37:36]

p_state

[sky, 2016/03/04 23:37:36]

Is there a reason to use windows types here rather than standard c++ types?

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

As it is a wrapper, wanted to keep the same signature and didn't want to have
implicit BOOL->bool cast.
Also, copied the whole wrapper approach for functions not available in previous
Windows versions from here [1].

[1]
https://chromium.googlesource.com/chromium/src/+blame/master/ui/base/win/touc...

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

+  typedef BOOL(WINAPI *GetAutoRotationStatePtr)(PAR_STATE);

[sky, 2016/03/04 23:37:36]

typedef->using

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

+  static GetAutoRotationStatePtr get_auto_rotation_state_func =
+    reinterpret_cast<GetAutoRotationStatePtr>(
+      GetProcAddress(GetModuleHandleA("user32.dll"),
+                     "GetAutoRotationState"));
+  if (get_auto_rotation_state_func)
+    return get_auto_rotation_state_func(pState);
+  return FALSE;
+}
+
+static void GetCurrentDisplaySettings(bool *landscape, bool *flipped) {

[sky, 2016/03/04 23:37:36]

Generally we put functions like this in an anonymous namespace and not static.

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

+  DEVMODE dm;
+  ZeroMemory(&dm, sizeof(dm));
+  dm.dmSize = sizeof(dm);
+  if (!EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm))

[sky, 2016/03/04 23:37:36]

Why do you use current and not the display the WebContents is on?

[sky, 2016/03/04 23:37:36]

nullptr

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

I have renamed the method GetCurrentDisplaySettings to
GetCurrentDisplayOrientation because "current settings ENUM_CURRENT_SETTINGS"
with "current display" could be a bit misleading.

First parameter (NULL) in documentation is described as "A NULL value specifies
the current display device on the computer on which the calling thread is
running."

ENUM_CURRENT_SETTINGS - specifies currently active settings for current device.

How Windows handles the cases where browser is displayed on extended screens
where one of those is rotated and the other isn't?
First parameter (NULL) is actually about "main" monitor - when setting multiple
windows one of the monitors is marked as main (Desktop->right mouse button
key->Screen resolution). Main monitor is by default the tablet monitor and in
multiple monitor mode user can change orientation of screens only through
Windows preferences for whole system (not per process like with this API). 

But the question is what would be the size of problem if this API returns e.g.
portrait from attached monitor with pivot rotation that user set to be main
monitor in preferences?
Then, while multiple monitors are attached, there would be no orientation change
comig from this API. Even after multiple monitors gets detached (then
orientation api change kicks in) and attached again, orientation gets disabled
again and it is in default state.
Orientation change kicks in only when multiple monitors get detached (or when
tablet is undocked, 2-in-1 transformed to tablet, etc). And in this case, it
would be intuitive to lock in the orientation it was displayed and explicitly
marked as main screen - so, keep the portrait. Important thing is that user
doesn't need to restart game after detaching to get the orientation lock
working.

Another ways would be to:
1) assume landscape 0 rotation in case with multiple monitors
2) disable orientation lock preference setting when there are multiple monitors
attached but both 1 and 2 seems wrong - I think the current way is correct.

[sky, 2016/03/07 16:20:30]

Again, why wouldn't you want to use the monitor the webcontents is on?

+    return;
+  if (flipped) {

[sky, 2016/03/04 23:37:36]

You always pass in non-null, so why check the variables?

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

+    *flipped = (dm.dmDisplayOrientation == DMDO_270

[sky, 2016/03/04 23:37:36]

Why not 90?

[mlamouri (slow - plz ping), 2016/03/05 00:39:14]

90 is "landscape-primary" and 270 "landscape-secondary" per screen orientation
spec.

+                || dm.dmDisplayOrientation == DMDO_180);
+  }
+  if (landscape)
+    *landscape = (dm.dmPelsWidth > dm.dmPelsHeight);
+}
+
+void ScreenOrientationDelegateWin::Lock(
+    content::WebContents* web_contents,
+    blink::WebScreenOrientationLockType lock_orientation) {
+  ORIENTATION_PREFERENCE prefs = ORIENTATION_PREFERENCE_NONE;
+  bool landscape = true;
+  bool flipped = false;
+  switch (lock_orientation) {
+    case blink::WebScreenOrientationLockPortraitPrimary:
+      prefs = ORIENTATION_PREFERENCE_PORTRAIT;
+      break;
+    case blink::WebScreenOrientationLockPortraitSecondary:
+      prefs = ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED;
+      break;
+    case blink::WebScreenOrientationLockLandscapePrimary:
+      prefs = ORIENTATION_PREFERENCE_LANDSCAPE;
+      break;
+    case blink::WebScreenOrientationLockLandscapeSecondary:

[sky, 2016/03/04 23:37:36]

What do primary and secondary mean in this context? The header doesn't seem to
have a description, so I'm asking.

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Got the information from spec [1] and copied the logic from @mlamouri's Android
patches [2]. Using this mapping:

Orientation API    | Android                             | Windows

portrait-primary   | SCREEN_ORIENTATION_PORTRAIT         |
ORIENTATION_PREFERENCE_PORTRAIT

portrait-secondary | SCREEN_ORIENTATION_REVERSE_PORTRAIT |
ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED
 
[1]
https://www.w3.org/TR/screen-orientation/#idl-def-OrientationLockType.portrai...
[2]
https://chromium.googlesource.com/chromium/src/+blame/master/content/public/a...

+      prefs = ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED;
+      break;
+    case blink::WebScreenOrientationLockPortrait:
+      GetCurrentDisplaySettings(&landscape, &flipped);
+      prefs = (flipped && !landscape) ? ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED
+                                      : ORIENTATION_PREFERENCE_PORTRAIT;
+      break;
+    case blink::WebScreenOrientationLockLandscape:
+      GetCurrentDisplaySettings(&landscape, &flipped);
+      prefs = (flipped && landscape) ? ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED
+                                     : ORIENTATION_PREFERENCE_LANDSCAPE;
+      break;
+    case blink::WebScreenOrientationLockNatural:
+      GetCurrentDisplaySettings(&landscape, &flipped);
+      prefs = landscape ? ORIENTATION_PREFERENCE_LANDSCAPE
+                        : ORIENTATION_PREFERENCE_PORTRAIT;
+      break;
+    case blink::WebScreenOrientationLockAny:
+      GetCurrentDisplaySettings(&landscape, &flipped);
+      if (landscape) {
+        prefs = flipped ? ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED
+                        : ORIENTATION_PREFERENCE_LANDSCAPE;
+      } else {
+        prefs = flipped ? ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED
+                        : ORIENTATION_PREFERENCE_PORTRAIT;
+      }
+      break;
+    case blink::WebScreenOrientationLockDefault:
+    default:
+      break;
+  }
+  SetDisplayAutoRotationPreferencesWrapper(prefs);
+}
+
+bool ScreenOrientationDelegateWin::ScreenOrientationProviderSupported() {
+  AR_STATE autoRotationState;

[sky, 2016/03/04 23:37:36]

auto_rotation_state

[aleksandar.stojiljkovic, 2016/03/06 10:34:15]

Done.

+  ZeroMemory(&autoRotationState, sizeof(AR_STATE));
+  return (GetAutoRotationStateWrapper(&autoRotationState)
+          && !(autoRotationState & AR_NOSENSOR)
+          && !(autoRotationState & AR_NOT_SUPPORTED));
+}
+
+void ScreenOrientationDelegateWin::Unlock(
+    content::WebContents* web_contents) {
+  SetDisplayAutoRotationPreferencesWrapper(ORIENTATION_PREFERENCE_NONE);
+}
+
+}  // namespace content