Bug 1974167 - Add API to set screen orientation override without enabling RDM. r=dom-core,smaug

lutien · lutien · commit e6e4456f8af9 · 2025-09-05T12:01:48.000Z
Differential Revision: https://phabricator.services.mozilla.com/D262787
diff --git a/docshell/base/BrowsingContext.cpp b/docshell/base/BrowsingContext.cpp
@@ -85,6 +85,7 @@
 #include "nsContentUtils.h"
 #include "nsQueryObject.h"
 #include "nsSandboxFlags.h"
+#include "nsScreen.h"
 #include "nsScriptError.h"
 #include "nsThreadUtils.h"
 #include "xpcprivate.h"
@@ -2972,9 +2973,53 @@ void BrowsingContext::DidSet(FieldIndex<IDX_InRDMPane>, bool aOldValue) {
   if (GetInRDMPane() == aOldValue) {
     return;
   }
+
+  // Reset screen orientation override when disabling RDM.
+  if (!GetInRDMPane()) {
+    ResetOrientationOverride();
+  }
+
   PresContextAffectingFieldChanged();
 }
 
+void BrowsingContext::DidSet(FieldIndex<IDX_HasOrientationOverride>,
+                             bool aOldValue) {
+  bool hasOrientationOverride = GetHasOrientationOverride();
+  OrientationType type = GetCurrentOrientationType();
+  float angle = GetCurrentOrientationAngle();
+
+  PreOrderWalk([&](BrowsingContext* aBrowsingContext) {
+    if (RefPtr<WindowContext> windowContext =
+            aBrowsingContext->GetCurrentWindowContext()) {
+      if (nsCOMPtr<nsPIDOMWindowInner> window =
+              windowContext->GetInnerWindow()) {
+        ScreenOrientation* orientation =
+            nsGlobalWindowInner::Cast(window)->Screen()->Orientation();
+
+        float screenOrientationAngle =
+            orientation->DeviceAngle(CallerType::System);
+        OrientationType screenOrientationType =
+            orientation->DeviceType(CallerType::System);
+
+        bool overrideIsDifferentThanDevice =
+            screenOrientationType != type || screenOrientationAngle != angle;
+
+        // Reset orientation override.
+        if (!hasOrientationOverride && aOldValue) {
+          Unused << aBrowsingContext->SetCurrentOrientation(
+              screenOrientationType, screenOrientationAngle);
+        } else if (!aBrowsingContext->IsTop()) {
+          // Sync orientation override in the existing frames.
+          Unused << aBrowsingContext->SetCurrentOrientation(type, angle);
+        }
+
+        orientation->MaybeDispatchEventsForOverride(
+            aBrowsingContext, aOldValue, overrideIsDifferentThanDevice);
+      }
+    }
+  });
+}
+
 void BrowsingContext::DidSet(FieldIndex<IDX_ForceDesktopViewport>,
                              bool aOldValue) {
   MOZ_ASSERT(IsTop(), "Should only set in the top-level browsing context");
diff --git a/docshell/base/BrowsingContext.h b/docshell/base/BrowsingContext.h
@@ -208,6 +208,7 @@ struct EmbedderColorSchemes {
   FIELD(CurrentOrientationAngle, float)                                       \
   FIELD(CurrentOrientationType, mozilla::dom::OrientationType)                \
   FIELD(OrientationLock, mozilla::hal::ScreenOrientation)                     \
+  FIELD(HasOrientationOverride, bool)                                         \
   FIELD(UserAgentOverride, nsString)                                          \
   FIELD(TouchEventsOverrideInternal, mozilla::dom::TouchEventsOverride)       \
   FIELD(EmbedderElementType, Maybe<nsString>)                                 \
@@ -691,13 +692,37 @@ class BrowsingContext : public nsILoadContext, public nsWrapperCache {
     return txn.Commit(this);
   }
 
-  void SetRDMPaneOrientation(OrientationType aType, float aAngle,
-                             ErrorResult& aRv) {
-    if (InRDMPane()) {
-      if (NS_FAILED(SetCurrentOrientation(aType, aAngle))) {
-        aRv.ThrowInvalidStateError("Browsing context is discarded");
-      }
+  bool HasOrientationOverride() const {
+    return Top()->GetHasOrientationOverride();
+  }
+
+  [[nodiscard]] nsresult SetOrientationOverride(OrientationType aType,
+                                                float aAngle) {
+    if (GetHasOrientationOverride() && GetCurrentOrientationType() == aType &&
+        GetCurrentOrientationAngle() == aAngle) {
+      return NS_OK;
     }
+
+    Transaction txn;
+    txn.SetCurrentOrientationType(aType);
+    txn.SetCurrentOrientationAngle(aAngle);
+    txn.SetHasOrientationOverride(true);
+    return txn.Commit(this);
+  }
+
+  void SetOrientationOverride(OrientationType aType, float aAngle,
+                              ErrorResult& aRv) {
+    MOZ_ASSERT(IsTop());
+
+    if (NS_FAILED(SetOrientationOverride(aType, aAngle))) {
+      aRv.ThrowInvalidStateError("Browsing context is discarded");
+    }
+  }
+
+  void ResetOrientationOverride() {
+    MOZ_ASSERT(IsTop());
+
+    Unused << SetHasOrientationOverride(false);
   }
 
   void SetRDMPaneMaxTouchPoints(uint8_t aMaxTouchPoints, ErrorResult& aRv) {
@@ -1171,6 +1196,7 @@ class BrowsingContext : public nsILoadContext, public nsWrapperCache {
   }
 
   void DidSet(FieldIndex<IDX_InRDMPane>, bool aOldValue);
+  void DidSet(FieldIndex<IDX_HasOrientationOverride>, bool aOldValue);
   MOZ_CAN_RUN_SCRIPT_BOUNDARY void DidSet(FieldIndex<IDX_ForceDesktopViewport>,
                                           bool aOldValue);
 
diff --git a/dom/base/ScreenOrientation.cpp b/dom/base/ScreenOrientation.cpp
@@ -75,8 +75,14 @@ ScreenOrientation::ScreenOrientation(nsPIDOMWindowInner* aWindow,
 
   Document* doc = GetResponsibleDocument();
   BrowsingContext* bc = doc ? doc->GetBrowsingContext() : nullptr;
-  if (bc && !bc->IsDiscarded() && !bc->InRDMPane()) {
+  if (bc && !bc->IsDiscarded() && !bc->HasOrientationOverride()) {
     MOZ_ALWAYS_SUCCEEDS(bc->SetCurrentOrientation(mType, mAngle));
+  } else if (bc && !bc->IsTop() && bc->HasOrientationOverride()) {
+    // Resync the override for newly created iframes.
+    BrowsingContext* topBC = bc->Top();
+    MOZ_ALWAYS_SUCCEEDS(
+        bc->SetOrientationOverride(topBC->GetCurrentOrientationType(),
+                                   topBC->GetCurrentOrientationAngle()));
   }
 }
 
@@ -820,29 +826,52 @@ void ScreenOrientation::MaybeChanged() {
     rv = bc->SetCurrentOrientation(mType, mAngle);
     NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "SetCurrentOrientation failed");
 
-    // change event has to be dispatched by descendantDocs.
-    // Looking for top level browsing context that has screen in process.
-    // If parent document has screen, we don't dispatch it at this time.
-    // change event will be dispatched by parent's
-    // ScreenOrientation::MaybeChanged.
-    BrowsingContext* rootBc = bc;
-    bool dispatchChangeEvent = true;
-    while (rootBc->GetParent()) {
-      rootBc = rootBc->GetParent();
-      if (Document* doc = rootBc->GetExtantDocument()) {
-        if (auto* win = nsGlobalWindowInner::Cast(doc->GetInnerWindow())) {
-          if (win->HasScreen()) {
-            // Parent of browsing context has screen object. Child shouldn't
-            // dispatch change event.
-            dispatchChangeEvent = false;
-            break;
-          }
+    MaybeDispatchChangeEvent(bc);
+  }
+}
+
+void ScreenOrientation::MaybeDispatchChangeEvent(
+    BrowsingContext* aBrowsingContext) {
+  // change event has to be dispatched by descendantDocs.
+  // Looking for top level browsing context that has screen in process.
+  // If parent document has screen, we don't dispatch it at this time.
+  // change event will be dispatched by parent's
+  // ScreenOrientation::MaybeChanged.
+  BrowsingContext* rootBc = aBrowsingContext;
+  bool dispatchChangeEvent = true;
+  while (rootBc->GetParent()) {
+    rootBc = rootBc->GetParent();
+    if (Document* doc = rootBc->GetExtantDocument()) {
+      if (auto* win = nsGlobalWindowInner::Cast(doc->GetInnerWindow())) {
+        if (win->HasScreen()) {
+          // Parent of browsing context has screen object. Child shouldn't
+          // dispatch change event.
+          dispatchChangeEvent = false;
+          break;
         }
       }
     }
-    if (dispatchChangeEvent) {
-      DispatchChangeEventToChildren(rootBc);
-    }
+  }
+  if (dispatchChangeEvent) {
+    DispatchChangeEventToChildren(rootBc);
+  }
+}
+
+void ScreenOrientation::MaybeDispatchEventsForOverride(
+    BrowsingContext* aBrowsingContext, bool aOldHasOrientationOverride,
+    bool aOverrideIsDifferentThanDevice) {
+  Document* doc = aBrowsingContext->GetExtantDocument();
+  nsCOMPtr<nsPIDOMWindowOuter> outerWindow = doc->GetWindow();
+
+  // Send the event if the orientation was already overriden or different
+  // from device metrics or the override was reset and it is different from
+  // device metrics.
+  if ((aBrowsingContext->HasOrientationOverride() &&
+          (aOldHasOrientationOverride || aOverrideIsDifferentThanDevice)) ||
+      (!aBrowsingContext->HasOrientationOverride() &&
+       aOldHasOrientationOverride && aOverrideIsDifferentThanDevice)) {
+    outerWindow->DispatchCustomEvent(u"orientationchange"_ns);
+    MaybeDispatchChangeEvent(aBrowsingContext);
   }
 }
 
diff --git a/dom/base/ScreenOrientation.h b/dom/base/ScreenOrientation.h
@@ -33,6 +33,15 @@ class ScreenOrientation final : public DOMEventTargetHelper {
   // Called when the orientation may have changed.
   void MaybeChanged();
 
+  // Called when we might need to dispatch orientation change event.
+  void MaybeDispatchChangeEvent(BrowsingContext* aBrowsingContext);
+
+  // Called when we might need to dispatch orientation change events
+  // in case of orientation override being set, updated or removed.
+  void MaybeDispatchEventsForOverride(BrowsingContext* aBrowsingContext,
+                                      bool aOldHasOrientationOverride,
+                                      bool aOverrideIsDifferentThanDevice);
+
   ScreenOrientation(nsPIDOMWindowInner* aWindow, nsScreen* aScreen);
 
   already_AddRefed<Promise> Lock(OrientationLockType aOrientation,
diff --git a/dom/base/test/browser.toml b/dom/base/test/browser.toml
@@ -152,6 +152,8 @@ support-files = [
   "file_browser_refresh_iframe.sjs",
 ]
 
+["browser_screen_orientation_override.js"]
+
 ["browser_set_focus_after_reuse_bcg.js"]
 
 ["browser_state_notifications.js"]
diff --git a/dom/base/test/browser_screen_orientation_override.js b/dom/base/test/browser_screen_orientation_override.js
@@ -0,0 +1,138 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const PAGE_URL =
+  "https://example.com/document-builder.sjs?html=<h1>Test orientation simulation</h1>";
+
+add_task(async function test_set_orientation_override() {
+  const tab = BrowserTestUtils.addTab(gBrowser, PAGE_URL);
+  const browser = gBrowser.getBrowserForTab(tab);
+
+  await BrowserTestUtils.browserLoaded(browser);
+
+  info("Get default orientation values");
+  const defaultOrientationAngle = await getOrientationAngle(browser);
+  const defaultOrientationType = await getOrientationType(browser);
+
+  info("Set orientation override");
+  const orientationAngleOverride1 = 180;
+  const orientationTypeOverride1 = "portrait-primary";
+  browser.browsingContext.setOrientationOverride(
+    orientationTypeOverride1,
+    orientationAngleOverride1
+  );
+
+  await assertOrientationOverride(
+    browser,
+    orientationAngleOverride1,
+    orientationTypeOverride1
+  );
+
+  info("Set another orientation override");
+  const orientationAngleOverride2 = 90;
+  const orientationTypeOverride2 = "landscape-secondary";
+  browser.browsingContext.setOrientationOverride(
+    orientationTypeOverride2,
+    orientationAngleOverride2
+  );
+
+  await assertOrientationOverride(
+    browser,
+    orientationAngleOverride2,
+    orientationTypeOverride2
+  );
+
+  info("Reset orientation override");
+  browser.browsingContext.resetOrientationOverride();
+
+  await assertOrientationOverride(
+    browser,
+    defaultOrientationAngle,
+    defaultOrientationType
+  );
+
+  BrowserTestUtils.removeTab(tab);
+});
+
+add_task(async function test_set_orientation_override_in_different_contexts() {
+  const tab1 = BrowserTestUtils.addTab(gBrowser, PAGE_URL);
+  const browser1 = gBrowser.getBrowserForTab(tab1);
+
+  await BrowserTestUtils.browserLoaded(browser1);
+
+  const tab2 = BrowserTestUtils.addTab(gBrowser, PAGE_URL);
+  const browser2 = gBrowser.getBrowserForTab(tab2);
+
+  await BrowserTestUtils.browserLoaded(browser2);
+
+  info("Get default orientation values");
+  const defaultOrientationAngle = await getOrientationAngle(browser1);
+  const defaultOrientationType = await getOrientationType(browser1);
+
+  info("Set orientation override to the first tab");
+  const orientationAngleOverride = 180;
+  const orientationTypeOverride = "portrait-primary";
+  browser1.browsingContext.setOrientationOverride(
+    orientationTypeOverride,
+    orientationAngleOverride
+  );
+
+  await assertOrientationOverride(
+    browser1,
+    orientationAngleOverride,
+    orientationTypeOverride
+  );
+
+  info("Make sure that in the second tab orientation is not overridden");
+  await assertOrientationOverride(
+    browser2,
+    defaultOrientationAngle,
+    defaultOrientationType
+  );
+
+  info("Reset orientation override in the first tab");
+  browser1.browsingContext.resetOrientationOverride();
+  await assertOrientationOverride(
+    browser1,
+    defaultOrientationAngle,
+    defaultOrientationType
+  );
+
+  BrowserTestUtils.removeTab(tab1);
+  BrowserTestUtils.removeTab(tab2);
+});
+
+async function assertOrientationOverride(
+  browser,
+  expectedAngleValue,
+  expectedTypeValue
+) {
+  is(
+    await getOrientationAngle(browser),
+    expectedAngleValue,
+    "screen.orientation.angle has expected value"
+  );
+  is(
+    await getOrientationType(browser),
+    expectedTypeValue,
+    "screen.orientation.type has expected value"
+  );
+}
+
+async function getOrientationAngle(browser) {
+  return await SpecialPowers.spawn(
+    browser,
+    [],
+    () => content.screen.orientation.angle
+  );
+}
+
+async function getOrientationType(browser) {
+  return await SpecialPowers.spawn(
+    browser,
+    [],
+    () => content.screen.orientation.type
+  );
+}
diff --git a/dom/chrome-webidl/BrowsingContext.webidl b/dom/chrome-webidl/BrowsingContext.webidl
@@ -198,8 +198,11 @@ interface BrowsingContext {
   [SetterThrows] attribute boolean useGlobalHistory;
 
   // Extension to give chrome JS the ability to set the window screen
-  // orientation while in RDM.
-  [Throws] undefined setRDMPaneOrientation(OrientationType type, float rotationAngle);
+  // orientation override with WebDriver BiDi and DevTools.
+  [Throws] undefined setOrientationOverride(OrientationType type, float rotationAngle);
+  // Extension to give chrome JS the ability to reset the window screen
+  // orientation override with WebDriver BiDi and DevTools.
+  undefined resetOrientationOverride();
 
   // Extension to give chrome JS the ability to set a maxTouchPoints override
   // while in RDM.

Original file line number	Diff line number	Diff line change
`@@ -152,6 +152,8 @@ support-files = [`
`152`	`152`	`"file_browser_refresh_iframe.sjs",`
`153`	`153`	`]`
`154`	`154`
	`155`	`+["browser_screen_orientation_override.js"]`
	`156`	`+`
`155`	`157`	`["browser_set_focus_after_reuse_bcg.js"]`
`156`	`158`
`157`	`159`	`["browser_state_notifications.js"]`