[Media Controls] Tests for rotate-to-fullscreen meets orientation lock

third_party/WebKit/Source/modules/media_controls/MediaControlsOrientationLockDelegate.cpp

 // 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 "modules/media_controls/MediaControlsOrientationLockDelegate.h"
 
 #include "core/events/Event.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/Screen.h"
 #include "core/frame/ScreenOrientationController.h"
@@ skipping 166 matching lines @@
   // If the rotate-to-fullscreen feature is also enabled, then start listening
   // to deviceorientation events so the orientation can be unlocked once the
   // user rotates the device to match the video's orientation (allowing the user
   // to then exit fullscreen by rotating their device back to the opposite
   // orientation). Otherwise, don't listen for deviceorientation events and just
   // hold the orientation lock until the user exits fullscreen (which prevents
   // the user rotating to the wrong fullscreen orientation).
   if (!RuntimeEnabledFeatures::VideoRotateToFullscreenEnabled())
     return;
 
+  if (is_auto_rotate_enabled_by_user_override_for_testing_ != WTF::nullopt) {
+    GotIsAutoRotateEnabledByUser(
+        is_auto_rotate_enabled_by_user_override_for_testing_.value());
+    return;
+  }
+
 // Check whether the user locked screen orientation at the OS level.
 #if OS(ANDROID)
   DCHECK(!monitor_.is_bound());
   Platform::Current()->GetConnector()->BindInterface(
       device::mojom::blink::kServiceName, mojo::MakeRequest(&monitor_));
   monitor_->IsAutoRotateEnabledByUser(ConvertToBaseCallback(WTF::Bind(
       &MediaControlsOrientationLockDelegate::GotIsAutoRotateEnabledByUser,
       WrapPersistent(this))));
 #else
   GotIsAutoRotateEnabledByUser(true);  // Assume always enabled on other OSes.
@@ skipping 93 matching lines @@
     case kWebScreenOrientationLandscapeSecondary:
       return kWebScreenOrientationLockLandscape;
     case kWebScreenOrientationUndefined:
       return kWebScreenOrientationLockLandscape;
   }
 
   NOTREACHED();
   return kWebScreenOrientationLockLandscape;
 }
 
-void MediaControlsOrientationLockDelegate::
-    MaybeUnlockIfDeviceOrientationMatchesVideo(DeviceOrientationEvent* event) {
-  DCHECK_EQ(state_, State::kMaybeLockedFullscreen);
-  DCHECK_NE(locked_orientation_, kWebScreenOrientationLockDefault);
-
+MediaControlsOrientationLockDelegate::DeviceOrientationType
+MediaControlsOrientationLockDelegate::ComputeDeviceOrientation(
+    DeviceOrientationData* data) const {
   LocalDOMWindow* dom_window = GetDocument().domWindow();
   if (!dom_window)
-    return;
+    return DeviceOrientationType::kUnknown;
 
-  if (!event->Orientation()->CanProvideBeta() ||
-      !event->Orientation()->CanProvideGamma()) {
-    return;
-  }
-  double beta = event->Orientation()->Beta();
-  double gamma = event->Orientation()->Gamma();
+  if (!data->CanProvideBeta() || !data->CanProvideGamma())
+    return DeviceOrientationType::kUnknown;
+  double beta = data->Beta();
+  double gamma = data->Gamma();
 
   // Calculate the projection of the up vector (normal to the earth's surface)
   // onto the device's screen in its natural orientation. (x,y) will lie within
   // the unit circle centered on (0,0), e.g. if the top of the device is
   // pointing upwards (x,y) will be (0,-1).
   double x = -std::sin(deg2rad(gamma)) * std::cos(deg2rad(beta));
   double y = -std::sin(deg2rad(beta));
 
   // Convert (x,y) to polar coordinates: 0 <= device_orientation_angle < 360 and
   // 0 <= r <= 1, such that device_orientation_angle is the clockwise angle in
   // degrees between the current physical orientation of the device and the
   // natural physical orientation of the device (ignoring the screen
   // orientation). Thus snapping device_orientation_angle to the nearest
   // multiple of 90 gives the value screen.orientation.angle would have if the
   // screen orientation was allowed to rotate freely to match the device
   // orientation. Note that we want device_orientation_angle==0 when the top of
   // the device is pointing upwards, but atan2's zero angle points to the right,
   // so we pass y=x and x=-y to atan2 to rotate by 90 degrees.
   double r = std::sqrt(x * x + y * y);
   double device_orientation_angle =
       std::fmod(rad2deg(std::atan2(/* y= */ x, /* x= */ -y)) + 360, 360);
 
+  // If angle between device's screen and the horizontal plane is less than
+  // kMinElevationAngle (chosen to approximately match Android's behavior), then
+  // device is too flat to reliably determine orientation.
   constexpr double kMinElevationAngle = 24;  // degrees from horizontal plane
   if (r < std::sin(deg2rad(kMinElevationAngle)))
-    return;  // Device is too flat to reliably determine orientation.
+    return DeviceOrientationType::kFlat;
 
   // device_orientation_angle snapped to nearest multiple of 90.
   int device_orientation_angle90 =
       std::lround(device_orientation_angle / 90) * 90;
 
-  if (std::abs(device_orientation_angle - device_orientation_angle90) > 23) {
-    // Device is diagonal (within 44 degree hysteresis zone).
-    return;
-  }
+  // To be considered portrait or landscape, allow the device to be rotated 23
+  // degrees (chosen to approximately match Android's behavior) to either side
+  // of those orientations. In the remaining 90 - 2*23 = 44 degree hysteresis
+  // zones, consider the device to be diagonal. These hysteresis zones prevent
+  // the computed orientation from oscillating rapidly between portrait and
+  // landscape when the device is in between the two orientations.
+  if (std::abs(device_orientation_angle - device_orientation_angle90) > 23)
+    return DeviceOrientationType::kDiagonal;
 
   // screen.orientation.angle is the standardized replacement for
   // window.orientation. They are equal, except -90 was replaced by 270.
   int screen_orientation_angle =
       ScreenScreenOrientation::orientation(nullptr /* ScriptState */,
                                            *dom_window->screen())
           ->angle();
 
   // This is equivalent to screen.orientation.type.startsWith('landscape').
-  bool screen_orientation_is_landscape =
-      dom_window->screen()->width() > dom_window->screen()->height();
+  bool screen_orientation_is_portrait =
+      dom_window->screen()->width() <= dom_window->screen()->height();
 
   // The natural orientation of the device could either be portrait (almost
   // all phones, and some tablets like Nexus 7) or landscape (other tablets
   // like Pixel C). Detect this by comparing angle to orientation.
   // TODO(johnme): This might get confused on square screens.
   bool screen_orientation_is_natural_or_flipped_natural =
       screen_orientation_angle % 180 == 0;
-  bool natural_orientation_is_landscape =
-      screen_orientation_is_landscape ==
+  bool natural_orientation_is_portrait =
+      screen_orientation_is_portrait ==
       screen_orientation_is_natural_or_flipped_natural;
 
-  bool natural_orientation_matches_video =
-      natural_orientation_is_landscape ==
-      (locked_orientation_ == kWebScreenOrientationLockLandscape);
+  // If natural_orientation_is_portrait_, then angles 0 and 180 are portrait,
+  // otherwise angles 90 and 270 are portrait.
+  int portrait_angle_mod_180 = natural_orientation_is_portrait ? 0 : 90;
+  return device_orientation_angle90 % 180 == portrait_angle_mod_180
+             ? DeviceOrientationType::kPortrait
+             : DeviceOrientationType::kLandscape;
+}
 
-  // If natural_orientation_matches_video, then 0 and 180 match video, otherwise
-  // 90 and 270 match video.
-  bool device_orientation_matches_video =
-      (device_orientation_angle90 % 180) ==
-      (natural_orientation_matches_video ? 0 : 90);
+void MediaControlsOrientationLockDelegate::
+    MaybeUnlockIfDeviceOrientationMatchesVideo(DeviceOrientationEvent* event) {
+  DCHECK_EQ(state_, State::kMaybeLockedFullscreen);
+  DCHECK(locked_orientation_ == kWebScreenOrientationLockPortrait ||
+         locked_orientation_ == kWebScreenOrientationLockLandscape);
 
-  if (!device_orientation_matches_video)
+  DeviceOrientationType device_orientation =
+      ComputeDeviceOrientation(event->Orientation());
+
+  DeviceOrientationType video_orientation =
+      locked_orientation_ == kWebScreenOrientationLockPortrait
+          ? DeviceOrientationType::kPortrait
+          : DeviceOrientationType::kLandscape;
+
+  if (device_orientation != video_orientation)
     return;
 
   // Job done: the user rotated their device to match the orientation of the
   // video that we locked to, so now we can unlock (and stop listening).
   MaybeUnlockOrientation();
 }
 
 DEFINE_TRACE(MediaControlsOrientationLockDelegate) {
   EventListener::Trace(visitor);
   visitor->Trace(video_element_);
 }
 
 }  // namespace blink