Switch Android VR tests to use embedded test server

As part of the work to use the permissions prompt by default, instead of
the custom consent dialogs, tests will need to be updated to use the
embedded test server rather than directly navigating to a file. This is
due to the fact that the Permissions code will DCHECK if saving the
permission for a file-type URL.

TODO:Revert changes to PermissionUtil and content_features, these are
currently loaded to validate that the tests will pass with these
changes.

Bug: 1043241
Change-Id: Iaa820812fac0bc389af47c22f8e069e81929b05a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2047987
Commit-Queue: Alexander Cooper <alcooper@chromium.org>
Reviewed-by: Brian Sheedy <bsheedy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#740399}

chrome/android/javatests/src/org/chromium/chrome/browser/vr/VrBrowserControllerInputTest.java

@@ -83,7 +83,7 @@ public class VrBrowserControllerInputTest {
     @Test
     @MediumTest
     public void testControllerScrolling() throws InterruptedException, Exception {
-        String url = VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_controller_scrolling");
+        String url = mVrBrowserTestFramework.getUrlForFile("test_controller_scrolling");
 
         final AtomicReference<RenderCoordinates> coord = new AtomicReference<RenderCoordinates>();
         Runnable waitScrollable = () -> {
@@ -109,8 +109,8 @@ public class VrBrowserControllerInputTest {
     @Test
     @MediumTest
     public void testControllerScrollingIframe() throws InterruptedException, Exception {
-        String url = VrBrowserTestFramework.getFileUrlForHtmlTestFile(
-                "test_controller_scrolling_iframe_outer");
+        String url =
+                mVrBrowserTestFramework.getUrlForFile("test_controller_scrolling_iframe_outer");
 
         Runnable waitScrollable = () -> {
             // We need to focus the iframe before we can start running JavaScript in it.
@@ -194,8 +194,7 @@ public class VrBrowserControllerInputTest {
     @Test
     @LargeTest
     public void testControllerFlingScrolling() throws InterruptedException {
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_controller_scrolling"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_controller_scrolling"),
                 PAGE_LOAD_TIMEOUT_S);
         final RenderCoordinates coord =
                 RenderCoordinates.fromWebContents(mVrTestRule.getWebContents());
@@ -324,13 +323,13 @@ public class VrBrowserControllerInputTest {
     @Test
     @MediumTest
     public void testControllerClicksRegisterOnWebpage() {
-        mVrTestRule.loadUrl(VrBrowserTestFramework.getFileUrlForHtmlTestFile(
-                                    "test_controller_clicks_register_on_webpage"),
+        mVrTestRule.loadUrl(
+                mVrBrowserTestFramework.getUrlForFile("test_controller_clicks_register_on_webpage"),
                 PAGE_LOAD_TIMEOUT_S);
 
         NativeUiUtils.clickElement(UserFriendlyElementName.CONTENT_QUAD, new PointF());
         ChromeTabUtils.waitForTabPageLoaded(mVrTestRule.getActivity().getActivityTab(),
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_navigation_2d_page"));
+                mVrBrowserTestFramework.getUrlForFile("test_navigation_2d_page"));
     }
 
     /**
@@ -342,14 +341,12 @@ public class VrBrowserControllerInputTest {
     @Test
     @MediumTest
     public void testControllerClicksRegisterOnIframe() {
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_iframe_clicks_outer"));
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_iframe_clicks_outer"));
         NativeUiUtils.clickElement(UserFriendlyElementName.CONTENT_QUAD, new PointF());
         // Wait until the iframe's current location matches the URL of the page that gets navigated
         // to on click.
         mVrBrowserTestFramework.pollJavaScriptBooleanInFrameOrFail("window.location.href == '"
-                        + VrBrowserTestFramework.getFileUrlForHtmlTestFile(
-                                  "test_iframe_clicks_inner_nav")
+                        + mVrBrowserTestFramework.getUrlForFile("test_iframe_clicks_inner_nav")
                         + "'",
                 POLL_TIMEOUT_SHORT_MS);
     }
@@ -364,23 +361,20 @@ public class VrBrowserControllerInputTest {
     public void testControllerScrollingNative() throws InterruptedException {
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
         // Fill history with enough items to scroll
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_navigation_2d_page"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_navigation_2d_page"),
                 PAGE_LOAD_TIMEOUT_S);
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_controller_scrolling"),
-                PAGE_LOAD_TIMEOUT_S);
-        mVrTestRule.loadUrl(VrBrowserTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_controller_scrolling"),
                 PAGE_LOAD_TIMEOUT_S);
         mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_navigation_webxr_page"),
-                PAGE_LOAD_TIMEOUT_S);
-        mVrTestRule.loadUrl(VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_webxr_input"),
-                PAGE_LOAD_TIMEOUT_S);
-        mVrTestRule.loadUrl(VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_webxr_consent"),
-                PAGE_LOAD_TIMEOUT_S);
-        mVrTestRule.loadUrl(VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_gamepad_button"),
+                mVrBrowserTestFramework.getUrlForFile("generic_webxr_page"), PAGE_LOAD_TIMEOUT_S);
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_navigation_webxr_page"),
                 PAGE_LOAD_TIMEOUT_S);
+        mVrTestRule.loadUrl(
+                mVrBrowserTestFramework.getUrlForFile("test_webxr_input"), PAGE_LOAD_TIMEOUT_S);
+        mVrTestRule.loadUrl(
+                mVrBrowserTestFramework.getUrlForFile("test_webxr_consent"), PAGE_LOAD_TIMEOUT_S);
+        mVrTestRule.loadUrl(
+                mVrBrowserTestFramework.getUrlForFile("test_gamepad_button"), PAGE_LOAD_TIMEOUT_S);
 
         mVrTestRule.loadUrl(UrlConstants.HISTORY_URL, PAGE_LOAD_TIMEOUT_S);
 
@@ -411,9 +405,8 @@ public class VrBrowserControllerInputTest {
     @Test
     @MediumTest
     public void testAppButtonExitsFullscreen() throws TimeoutException {
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_navigation_2d_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "test_navigation_2d_page", PAGE_LOAD_TIMEOUT_S);
         // Enter fullscreen
         DOMUtils.clickNode(mVrBrowserTestFramework.getCurrentWebContents(), "fullscreen",
                 false /* goThroughRootAndroidView */);
@@ -444,8 +437,7 @@ public class VrBrowserControllerInputTest {
     @Test
     @MediumTest
     public void testDragRefresh() {
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_controller_scrolling"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_controller_scrolling"),
                 PAGE_LOAD_TIMEOUT_S);
         waitForPageToBeScrollable(RenderCoordinates.fromWebContents(mVrTestRule.getWebContents()));
         // The navigationStart time should change anytime we refresh, so save the value and compare

chrome/android/javatests/src/org/chromium/chrome/browser/vr/VrBrowserDialogTest.java

@@ -91,11 +91,7 @@ public class VrBrowserDialogTest {
     }
 
     private void navigateAndDisplayPermissionPrompt(String page, final String promptCommand) {
-        // Trying to grant permissions on file:// URLs ends up hitting DCHECKS, so load from a local
-        // server instead.
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                mVrBrowserTestFramework.getEmbeddedServerUrlForHtmlTestFile(page),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(page, PAGE_LOAD_TIMEOUT_S);
 
         // Display the given permission prompt.
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);

chrome/android/javatests/src/org/chromium/chrome/browser/vr/VrBrowserNativeUiTest.java

@@ -65,9 +65,6 @@ public class VrBrowserNativeUiTest {
 
     private VrBrowserTestFramework mVrBrowserTestFramework;
 
-    private static final String TEST_PAGE_2D_URL =
-            VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_navigation_2d_page");
-
     @Before
     public void setUp() {
         mVrBrowserTestFramework = new VrBrowserTestFramework(mVrTestRule);
@@ -93,7 +90,8 @@ public class VrBrowserNativeUiTest {
     @Test
     @MediumTest
     public void testUrlOnNonNativeUi() throws IllegalArgumentException {
-        mVrTestRule.loadUrl(TEST_PAGE_2D_URL, PAGE_LOAD_TIMEOUT_S);
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_navigation_2d_page"),
+                PAGE_LOAD_TIMEOUT_S);
         Assert.assertTrue("URL is not being show for non-native page",
                 TestVrShellDelegate.isDisplayingUrlForTesting());
     }
@@ -105,10 +103,8 @@ public class VrBrowserNativeUiTest {
     @Test
     @MediumTest
     public void testPaymentRequest() {
-        // We can't request payment on file:// URLs, so use a local server.
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                mVrBrowserTestFramework.getEmbeddedServerUrlForHtmlTestFile("test_payment_request"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "test_payment_request", PAGE_LOAD_TIMEOUT_S);
         // Set up an observer so we'll know if the payment request is shown.
         AtomicBoolean requestShown = new AtomicBoolean(false);
         PaymentRequestObserverForTest observer = new PaymentRequestObserverForTest() {
@@ -364,8 +360,8 @@ public class VrBrowserNativeUiTest {
     @Feature({"Browser", "RenderTest"})
     public void testFileUrlEmphasis() throws InterruptedException, IOException {
         NativeUiUtils.enableMockedInput();
-        mVrTestRule.loadUrl(VrBrowserTestFramework.getFileUrlForHtmlTestFile("2d_permission_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrTestRule.loadUrl(
+                mVrBrowserTestFramework.getUrlForFile("2d_permission_page"), PAGE_LOAD_TIMEOUT_S);
         NativeUiUtils.waitForUiQuiescence();
         RenderTestUtils.dumpAndCompare(NativeUiUtils.FRAME_BUFFER_SUFFIX_BROWSER_UI,
                 "file_url_emphasis_browser_ui", mRenderTestRule);
@@ -381,8 +377,7 @@ public class VrBrowserNativeUiTest {
             throws InterruptedException, TimeoutException, IOException {
         // Use the mock keyboard so it doesn't show, reducing the chance of flakes due to AA.
         NativeUiUtils.enableMockedKeyboard();
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("generic_text_entry_page"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("generic_text_entry_page"),
                 PAGE_LOAD_TIMEOUT_S);
         NativeUiUtils.clickContentNode(
                 "textfield", new PointF(), 1 /* numClicks */, mVrBrowserTestFramework);
@@ -595,10 +590,8 @@ public class VrBrowserNativeUiTest {
     @MediumTest
     @Feature({"Browser", "RenderTest"})
     public void testScrollResizing() throws InterruptedException, IOException {
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile(
-                        "test_content_resizing_does_not_affect_webpage"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "test_content_resizing_does_not_affect_webpage", PAGE_LOAD_TIMEOUT_S);
         mVrBrowserTestFramework.executeStepAndWait("stepGetInitialDimensions()");
         resizeContentWindowToMinimum();
         RenderTestUtils.dumpAndCompare(
@@ -616,8 +609,7 @@ public class VrBrowserNativeUiTest {
     @Feature({"Browser", "RenderTest"})
     public void testOverflowAndKeyboardFollowContentQuad()
             throws InterruptedException, TimeoutException, IOException {
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("generic_text_entry_page"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("generic_text_entry_page"),
                 PAGE_LOAD_TIMEOUT_S);
         // Drag the content quad up and to the left.
         NativeUiUtils.selectRepositionBar();
@@ -646,10 +638,8 @@ public class VrBrowserNativeUiTest {
     @MediumTest
     @CommandLineFlags.Add({"enable-features=WebXR"})
     public void testRAFsFireWhileRepositioning() {
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile(
-                        "test_rafs_fire_while_repositioning"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "test_rafs_fire_while_repositioning", PAGE_LOAD_TIMEOUT_S);
         NativeUiUtils.selectRepositionBar();
         mVrBrowserTestFramework.executeStepAndWait("stepCheckForRafs()");
         mVrBrowserTestFramework.endTest();
@@ -663,10 +653,8 @@ public class VrBrowserNativeUiTest {
     @Feature({"Browser", "RenderTest"})
     public void testRepositionBarDoesNotAppearWithPermissionPromptVisible()
             throws InterruptedException, IOException {
-        // We don't need to actually accept the prompt, so we don't need to use the local server.
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("2d_permission_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "2d_permission_page", PAGE_LOAD_TIMEOUT_S);
         NativeUiUtils.enableMockedInput();
         NativeUiUtils.waitForUiQuiescence();
         NativeUiUtils.performActionAndWaitForUiQuiescence(() -> {
@@ -752,9 +740,8 @@ public class VrBrowserNativeUiTest {
     @MediumTest
     public void testVoiceInputUnavailableIfSiteUsingMicrophone() throws InterruptedException {
         NativeUiUtils.enableMockedInput();
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                mVrBrowserTestFramework.getEmbeddedServerUrlForHtmlTestFile("2d_permission_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "2d_permission_page", PAGE_LOAD_TIMEOUT_S);
         // Wait for any residual animations from navigating.
         NativeUiUtils.waitForUiQuiescence();
         // Display and accept the permission.
@@ -819,8 +806,7 @@ public class VrBrowserNativeUiTest {
     private void testSecurityTokenImpl(String identifier) throws InterruptedException, IOException {
         NativeUiUtils.enableMockedInput();
         mVrTestRule.loadUrl(
-                mVrBrowserTestFramework.getEmbeddedServerUrlForHtmlTestFile("2d_permission_page"),
-                PAGE_LOAD_TIMEOUT_S);
+                mVrBrowserTestFramework.getUrlForFile("2d_permission_page"), PAGE_LOAD_TIMEOUT_S);
         // Wait for any residual animations from loading to go away.
         NativeUiUtils.waitForUiQuiescence();
         RenderTestUtils.dumpAndCompare(NativeUiUtils.FRAME_BUFFER_SUFFIX_BROWSER_UI,

chrome/android/javatests/src/org/chromium/chrome/browser/vr/VrBrowserTransitionTest.java

@@ -162,8 +162,7 @@ public class VrBrowserTransitionTest {
 
     private String testVrEntryIntentInternal() {
         // Send a VR intent, which will open the link in a CTA.
-        final String url =
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_navigation_2d_page");
+        final String url = mVrBrowserTestFramework.getUrlForFile("test_navigation_2d_page");
         VrBrowserTransitionUtils.sendVrLaunchIntent(url);
 
         // Wait until we enter VR and have the correct URL.
@@ -213,9 +212,8 @@ public class VrBrowserTransitionTest {
     @MediumTest
     public void testExitFullscreenAfterExitingVrFromCinemaMode() throws TimeoutException {
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_navigation_2d_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "test_navigation_2d_page", PAGE_LOAD_TIMEOUT_S);
         DOMUtils.clickNode(mVrBrowserTestFramework.getCurrentWebContents(), "fullscreen",
                 false /* goThroughRootAndroidView */);
         mVrBrowserTestFramework.waitOnJavaScriptStep();
@@ -249,14 +247,12 @@ public class VrBrowserTransitionTest {
     @Restriction(RESTRICTION_TYPE_VIEWER_DAYDREAM_OR_STANDALONE)
     @MediumTest
     public void testExitPresentationWebXrToVrShell() throws IllegalArgumentException {
-        exitPresentationToVrShellImpl(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_navigation_webxr_page"),
-                mWebXrVrTestFramework);
+        exitPresentationToVrShellImpl("test_navigation_webxr_page", mWebXrVrTestFramework);
     }
 
     private void exitPresentationToVrShellImpl(String url, WebXrVrTestFramework framework) {
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         VrShell vrShell = TestVrShellDelegate.getVrShellForTesting();
         float expectedWidth = vrShell.getContentWidthForTesting();
         float expectedHeight = vrShell.getContentHeightForTesting();
@@ -284,25 +280,22 @@ public class VrBrowserTransitionTest {
     @Restriction(RESTRICTION_TYPE_VIEWER_DAYDREAM_OR_STANDALONE)
     @MediumTest
     public void testWebXrReEntryFromVrBrowser() {
-        reEntryFromVrBrowserImpl(WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                                         "test_webxr_reentry_from_vr_browser"),
-                mWebXrVrTestFramework, false);
+        reEntryFromVrBrowserImpl(
+                "test_webxr_reentry_from_vr_browser", mWebXrVrTestFramework, false);
     }
 
     @Test
     @Restriction(RESTRICTION_TYPE_VIEWER_DAYDREAM_OR_STANDALONE)
     @MediumTest
     public void testWebXrReEntryFromVrBrowserViaEndSession() {
-        reEntryFromVrBrowserImpl(WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                                         "test_webxr_reentry_from_vr_browser"),
-                mWebXrVrTestFramework, true);
+        reEntryFromVrBrowserImpl("test_webxr_reentry_from_vr_browser", mWebXrVrTestFramework, true);
     }
 
     private void reEntryFromVrBrowserImpl(
             String url, WebXrVrTestFramework framework, boolean useEndSession) {
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
 
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.enterSessionWithUserGestureOrFail();
 
         framework.executeStepAndWait("stepVerifyFirstPresent()");
@@ -438,9 +431,8 @@ public class VrBrowserTransitionTest {
     @Restriction(RESTRICTION_TYPE_VIEWER_DAYDREAM)
     @LargeTest
     public void testExitVrWithPromptDisplayed() {
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_navigation_2d_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "test_navigation_2d_page", PAGE_LOAD_TIMEOUT_S);
 
         // Test JavaScript dialogs.
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
@@ -529,11 +521,8 @@ public class VrBrowserTransitionTest {
     @Restriction({RESTRICTION_TYPE_VIEWER_DAYDREAM})
     @MediumTest
     public void testPermissionsPersistWhenEnteringVrBrowser() {
-        // Permissions don't work on file:// URLs, so use a local server.
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                mVrBrowserTestFramework.getEmbeddedServerUrlForHtmlTestFile(
-                        "test_permissions_persist_when_entering_vr_browser"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "test_permissions_persist_when_entering_vr_browser", PAGE_LOAD_TIMEOUT_S);
         // Ensure that permission requests initially trigger a prompt.
         Assert.assertTrue("Camera permission would not trigger prompt",
                 mVrBrowserTestFramework.permissionRequestWouldTriggerPrompt("camera"));
@@ -547,10 +536,8 @@ public class VrBrowserTransitionTest {
         PermissionUtils.acceptPermissionPrompt();
         mVrBrowserTestFramework.waitOnJavaScriptStep();
         // Reload the page and ensure that the permissions are still granted.
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                mVrBrowserTestFramework.getEmbeddedServerUrlForHtmlTestFile(
-                        "test_permissions_persist_when_entering_vr_browser"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "test_permissions_persist_when_entering_vr_browser", PAGE_LOAD_TIMEOUT_S);
         Assert.assertFalse("Camera permission would trigger prompt after reload",
                 mVrBrowserTestFramework.permissionRequestWouldTriggerPrompt("camera"));
         Assert.assertFalse("Microphone permission would trigger prompt after reload",

chrome/android/javatests/src/org/chromium/chrome/browser/vr/VrBrowserWebInputEditingTest.java

@@ -78,8 +78,7 @@ public class VrBrowserWebInputEditingTest {
     @MediumTest
     @CommandLineFlags.Add("enable-features=VrLaunchIntents")
     public void testWebInputFocus() throws InterruptedException {
-        testWebInputFocusImpl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_web_input_editing"));
+        testWebInputFocusImpl(mVrBrowserTestFramework.getUrlForFile("test_web_input_editing"));
     }
 
     /**
@@ -91,8 +90,8 @@ public class VrBrowserWebInputEditingTest {
     @MediumTest
     @CommandLineFlags.Add("enable-features=VrLaunchIntents")
     public void testWebInputFocusIframe() throws InterruptedException {
-        testWebInputFocusImpl(VrBrowserTestFramework.getFileUrlForHtmlTestFile(
-                "test_web_input_editing_iframe_outer"));
+        testWebInputFocusImpl(
+                mVrBrowserTestFramework.getUrlForFile("test_web_input_editing_iframe_outer"));
     }
 
     private void testWebInputFocusImpl(String url) throws InterruptedException {
@@ -154,8 +153,8 @@ public class VrBrowserWebInputEditingTest {
     @Test
     @MediumTest
     public void testSelectTag() throws TimeoutException {
-        mVrTestRule.loadUrl(VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_select_tag"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrTestRule.loadUrl(
+                mVrBrowserTestFramework.getUrlForFile("test_select_tag"), PAGE_LOAD_TIMEOUT_S);
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
         NativeUiUtils.enableMockedInput();
         // Click on the <select> tag and wait for the resulting modal dialog to appear.
@@ -198,8 +197,7 @@ public class VrBrowserWebInputEditingTest {
     @Test
     @MediumTest
     public void testKeyboardAutomaticallyClosesOnNavigation() throws InterruptedException {
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_web_input_editing"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_web_input_editing"),
                 PAGE_LOAD_TIMEOUT_S);
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
 
@@ -222,8 +220,7 @@ public class VrBrowserWebInputEditingTest {
                 POLL_CHECK_INTERVAL_SHORT_MS);
 
         // Navigate to a different page and ensure the keyboard automatically hides.
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_navigation_2d_page"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_navigation_2d_page"),
                 PAGE_LOAD_TIMEOUT_S);
         // The hiding should be done by the time navigation completes, so assert instead of polling.
         Assert.assertFalse(
@@ -240,8 +237,8 @@ public class VrBrowserWebInputEditingTest {
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
         NativeUiUtils.enableMockedInput();
         NativeUiUtils.enableMockedKeyboard();
-        mVrTestRule.loadUrl(VrBrowserTestFramework.getFileUrlForHtmlTestFile(
-                                    "test_web_input_cursor_reposition"),
+        mVrTestRule.loadUrl(
+                mVrBrowserTestFramework.getUrlForFile("test_web_input_cursor_reposition"),
                 PAGE_LOAD_TIMEOUT_S);
         NativeUiUtils.clickContentNode(
                 "textfield", new PointF(), 1 /* numClicks */, mVrBrowserTestFramework);
@@ -282,8 +279,7 @@ public class VrBrowserWebInputEditingTest {
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
         NativeUiUtils.enableMockedInput();
         NativeUiUtils.enableMockedKeyboard();
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_web_input_selection"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_web_input_selection"),
                 PAGE_LOAD_TIMEOUT_S);
         NativeUiUtils.clickContentNode(
                 "textfield", new PointF(), 1 /* numClicks */, mVrBrowserTestFramework);
@@ -329,8 +325,7 @@ public class VrBrowserWebInputEditingTest {
     @MediumTest
     public void testClicksHideKeyboard() throws InterruptedException, TimeoutException {
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("generic_text_entry_page"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("generic_text_entry_page"),
                 PAGE_LOAD_TIMEOUT_S);
         NativeUiUtils.enableMockedInput();
 
@@ -400,8 +395,7 @@ public class VrBrowserWebInputEditingTest {
     @MediumTest
     public void testAppButtonHidesKeyboard() throws InterruptedException, TimeoutException {
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("generic_text_entry_page"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("generic_text_entry_page"),
                 PAGE_LOAD_TIMEOUT_S);
         NativeUiUtils.enableMockedInput();
 
@@ -451,9 +445,8 @@ public class VrBrowserWebInputEditingTest {
         mRenderTestRule.setPixelDiffThreshold(2);
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
         NativeUiUtils.enableMockedInput();
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_video_controls"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "test_video_controls", PAGE_LOAD_TIMEOUT_S);
 
         // Click the fullscreen button. We use a separate button instead of the controls' fullscreen
         // button since that's more stable.

chrome/android/javatests/src/org/chromium/chrome/browser/vr/VrFeedbackInfoBarTest.java

@@ -49,10 +49,8 @@ public class VrFeedbackInfoBarTest {
     private WebXrVrTestFramework mWebXrVrTestFramework;
     private VrBrowserTestFramework mVrBrowserTestFramework;
 
-    private static final String TEST_PAGE_2D_URL =
-            VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_navigation_2d_page");
-    private static final String TEST_PAGE_WEBXR_URL =
-            WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page");
+    private static final String TEST_PAGE_2D_FILE = "test_navigation_2d_page";
+    private static final String TEST_PAGE_WEBXR_FILE = "generic_webxr_page";
 
     @Before
     public void setUp() {
@@ -81,8 +79,8 @@ public class VrFeedbackInfoBarTest {
     @MediumTest
     @Restriction(RESTRICTION_TYPE_VIEWER_DAYDREAM)
     public void testFeedbackFrequency() {
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                TEST_PAGE_2D_URL, PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                TEST_PAGE_2D_FILE, PAGE_LOAD_TIMEOUT_S);
         // Set frequency of infobar to every 2nd time.
         VrShellDelegateUtils.getDelegateInstance().setFeedbackFrequencyForTesting(2);
 
@@ -109,8 +107,8 @@ public class VrFeedbackInfoBarTest {
     @MediumTest
     @Restriction(RESTRICTION_TYPE_VIEWER_DAYDREAM)
     public void testFeedbackOptOut() {
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                TEST_PAGE_2D_URL, PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                TEST_PAGE_2D_FILE, PAGE_LOAD_TIMEOUT_S);
 
         // Show infobar every time.
         VrShellDelegateUtils.getDelegateInstance().setFeedbackFrequencyForTesting(1);
@@ -136,12 +134,12 @@ public class VrFeedbackInfoBarTest {
     @MediumTest
             @CommandLineFlags.Add({"enable-features=WebXR"})
             public void testFeedbackOnlyOnVrBrowsing_WebXr() {
-        feedbackOnlyOnVrBrowsingImpl(TEST_PAGE_WEBXR_URL, mWebXrVrTestFramework);
+        feedbackOnlyOnVrBrowsingImpl(TEST_PAGE_WEBXR_FILE, mWebXrVrTestFramework);
     }
 
     private void feedbackOnlyOnVrBrowsingImpl(String url, WebXrVrTestFramework framework) {
         // Enter VR presentation mode.
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.enterSessionWithUserGestureOrFail();
         assertState(true /* isInVr */, false /* isInfobarVisible  */);
         Assert.assertTrue("Did not enter WebVR presentation",
@@ -166,19 +164,20 @@ public class VrFeedbackInfoBarTest {
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
 
         // Enter VR presentation mode.
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                TEST_PAGE_WEBXR_URL, PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                TEST_PAGE_WEBXR_FILE, PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.enterSessionWithUserGestureOrFail();
         assertState(true /* isInVr */, false /* isInfobarVisible  */);
         Assert.assertTrue("Did not enter WebVR presentation",
                 TestVrShellDelegate.getVrShellForTesting().getWebVrModeEnabled());
 
+        String page2DUrl = mWebXrVrTestFramework.getUrlForFile(TEST_PAGE_2D_FILE);
+
         // Exit presentation mode by navigating to a different url.
         ChromeTabUtils.waitForTabPageLoaded(
-                mTestRule.getActivity().getActivityTab(), TEST_PAGE_2D_URL, () -> {
+                mTestRule.getActivity().getActivityTab(), page2DUrl, () -> {
                     mVrBrowserTestFramework.runJavaScriptOrFail(
-                            "window.location.href = '" + TEST_PAGE_2D_URL + "';",
-                            POLL_TIMEOUT_SHORT_MS);
+                            "window.location.href = '" + page2DUrl + "';", POLL_TIMEOUT_SHORT_MS);
                 }, POLL_TIMEOUT_LONG_MS);
 
         // Exiting VR should prompt for feedback since 2D browsing was performed after.

chrome/android/javatests/src/org/chromium/chrome/browser/vr/VrInstallUpdateInfoBarTest.java

@@ -64,9 +64,12 @@ public class VrInstallUpdateInfoBarTest {
 
     private ChromeActivityTestRule mVrTestRule;
 
+    private VrBrowserTestFramework mVrBrowserTestFramework;
+
     public VrInstallUpdateInfoBarTest(Callable<ChromeActivityTestRule> callable) throws Exception {
         mVrTestRule = callable.call();
         mRuleChain = VrTestRuleUtils.wrapRuleInActivityRestrictionRule(mVrTestRule);
+        mVrBrowserTestFramework = new VrBrowserTestFramework(mVrTestRule);
     }
 
     /**
@@ -181,8 +184,7 @@ public class VrInstallUpdateInfoBarTest {
     }
 
     private void testKeyboardInstallUpgradeImpl(final int uiElementToClick) {
-        mVrTestRule.loadUrl(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("test_web_input_editing"),
+        mVrTestRule.loadUrl(mVrBrowserTestFramework.getUrlForFile("test_web_input_editing"),
                 PAGE_LOAD_TIMEOUT_S);
         GvrKeyboardLoaderClient.setFailLoadForTesting(true);
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);

chrome/android/javatests/src/org/chromium/chrome/browser/vr/WebXrArHitTestTest.java

@@ -67,10 +67,8 @@ public class WebXrArHitTestTest {
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     @ArPlaybackFile("chrome/test/data/xr/ar_playback_datasets/floor_short_start_with_plane.mp4")
     public void testHitTestSucceedsWithPlane() {
-        mWebXrArTestFramework.loadUrlAndAwaitInitialization(
-                mWebXrArTestFramework.getEmbeddedServerUrlForHtmlTestFile(
-                        "webxr_test_basic_hittest"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrArTestFramework.loadFileAndAwaitInitialization(
+                "webxr_test_basic_hittest", PAGE_LOAD_TIMEOUT_S);
         mWebXrArTestFramework.enterSessionWithUserGestureOrFail();
         mWebXrArTestFramework.executeStepAndWait("stepStartHitTesting()");
         mWebXrArTestFramework.assertNoJavaScriptErrors();

chrome/android/javatests/src/org/chromium/chrome/browser/vr/WebXrArSessionTest.java

@@ -68,10 +68,8 @@ public class WebXrArSessionTest {
     @MediumTest
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testArRequestSessionSucceeds() {
-        mWebXrArTestFramework.loadUrlAndAwaitInitialization(
-                mWebXrArTestFramework.getEmbeddedServerUrlForHtmlTestFile(
-                        "test_ar_request_session_succeeds"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrArTestFramework.loadFileAndAwaitInitialization(
+                "test_ar_request_session_succeeds", PAGE_LOAD_TIMEOUT_S);
         mWebXrArTestFramework.enterSessionWithUserGestureOrFail();
         mWebXrArTestFramework.assertNoJavaScriptErrors();
     }
@@ -85,10 +83,8 @@ public class WebXrArSessionTest {
     @MediumTest
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testConsentPersistanceOnSamePage() {
-        mWebXrArTestFramework.loadUrlAndAwaitInitialization(
-                mWebXrArTestFramework.getEmbeddedServerUrlForHtmlTestFile(
-                        "test_ar_request_session_succeeds"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrArTestFramework.loadFileAndAwaitInitialization(
+                "test_ar_request_session_succeeds", PAGE_LOAD_TIMEOUT_S);
         WebContents contents = mWebXrArTestFramework.getCurrentWebContents();
 
         // Start session, decline consent prompt.
@@ -119,10 +115,8 @@ public class WebXrArSessionTest {
     @MediumTest
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testRepeatedArSessionsSucceed() {
-        mWebXrArTestFramework.loadUrlAndAwaitInitialization(
-                mWebXrArTestFramework.getEmbeddedServerUrlForHtmlTestFile(
-                        "test_ar_request_session_succeeds"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrArTestFramework.loadFileAndAwaitInitialization(
+                "test_ar_request_session_succeeds", PAGE_LOAD_TIMEOUT_S);
         for (int i = 0; i < 2; i++) {
             mWebXrArTestFramework.enterSessionWithUserGestureOrFail();
             mWebXrArTestFramework.endSession();

chrome/android/javatests/src/org/chromium/chrome/browser/vr/WebXrVrConsentTest.java

@@ -71,9 +71,8 @@ public class WebXrVrConsentTest {
                 WebXrVrTestFramework.CONSENT_DIALOG_ACTION_DENY);
         mWebXrVrConsentTestFramework.setConsentDialogExpected(true);
 
-        mWebXrVrConsentTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_webxr_consent"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrConsentTestFramework.loadFileAndAwaitInitialization(
+                "test_webxr_consent", PAGE_LOAD_TIMEOUT_S);
 
         mWebXrVrConsentTestFramework.enterSessionWithUserGesture();
         mWebXrVrConsentTestFramework.pollJavaScriptBooleanOrFail(
@@ -91,9 +90,8 @@ public class WebXrVrConsentTest {
     @MediumTest
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testConsentPersistsSameLevel() {
-        mWebXrVrConsentTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrConsentTestFramework.loadFileAndAwaitInitialization(
+                "generic_webxr_page", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrConsentTestFramework.enterSessionWithUserGestureOrFail();
         mWebXrVrConsentTestFramework.endSession();
 
@@ -112,9 +110,8 @@ public class WebXrVrConsentTest {
     public void testConsentNotNeededForInline() {
         mWebXrVrConsentTestFramework.setConsentDialogExpected(false);
 
-        mWebXrVrConsentTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_webxr_consent"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrConsentTestFramework.loadFileAndAwaitInitialization(
+                "test_webxr_consent", PAGE_LOAD_TIMEOUT_S);
 
         mWebXrVrConsentTestFramework.runJavaScriptOrFail(
                 "requestMagicWindowSession()", POLL_TIMEOUT_SHORT_MS);
@@ -130,9 +127,8 @@ public class WebXrVrConsentTest {
     @MediumTest
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testConsentPersistsLowerLevel() {
-        mWebXrVrConsentTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_webxr_consent"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrConsentTestFramework.loadFileAndAwaitInitialization(
+                "test_webxr_consent", PAGE_LOAD_TIMEOUT_S);
 
         // Set up to request the highest level of consent support on Android (height).
         mWebXrVrConsentTestFramework.runJavaScriptOrFail(
@@ -155,9 +151,8 @@ public class WebXrVrConsentTest {
     @MediumTest
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testConsentRepromptsHigherLevel() {
-        mWebXrVrConsentTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_webxr_consent"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrConsentTestFramework.loadFileAndAwaitInitialization(
+                "test_webxr_consent", PAGE_LOAD_TIMEOUT_S);
 
         // Request a session at the lowest level of consent, and ensure that it is entered.
         mWebXrVrConsentTestFramework.runJavaScriptOrFail(
@@ -179,16 +174,14 @@ public class WebXrVrConsentTest {
     @MediumTest
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testConsentRepromptsAfterReload() {
-        mWebXrVrConsentTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrConsentTestFramework.loadFileAndAwaitInitialization(
+                "generic_webxr_page", PAGE_LOAD_TIMEOUT_S);
 
         mWebXrVrConsentTestFramework.enterSessionWithUserGestureOrFail();
         mWebXrVrConsentTestFramework.endSession();
 
-        mWebXrVrConsentTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrConsentTestFramework.loadFileAndAwaitInitialization(
+                "generic_webxr_page", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrConsentTestFramework.enterSessionWithUserGestureOrFail();
     }
 }

chrome/android/javatests/src/org/chromium/chrome/browser/vr/WebXrVrDeviceTest.java

@@ -76,9 +76,8 @@ public class WebXrVrDeviceTest {
             @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
             @MinAndroidSdkLevel(Build.VERSION_CODES.LOLLIPOP) // WebXR is only supported on L+
             public void testWebXrCapabilities() {
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_webxr_capabilities"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_webxr_capabilities", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.executeStepAndWait("stepCheckCapabilities('Daydream')");
         mWebXrVrTestFramework.endTest();
     }
@@ -99,9 +98,8 @@ public class WebXrVrDeviceTest {
             @MinAndroidSdkLevel(Build.VERSION_CODES.LOLLIPOP) // WebXR is only supported on L+
             public void testForNullPosesInInlineVrPostImmersive() {
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_inline_vr_poses"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_inline_vr_poses", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.enterMagicWindowSessionWithUserGestureOrFail();
 
         mWebXrVrTestFramework.enterSessionWithUserGestureOrFail();
@@ -135,9 +133,8 @@ public class WebXrVrDeviceTest {
     @Restriction(RESTRICTION_TYPE_VIEWER_DAYDREAM)
     @MinAndroidSdkLevel(Build.VERSION_CODES.LOLLIPOP) // WebXR is only supported on L+
     public void testForNullPosesInInlineVrFromNfc() {
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_inline_vr_poses"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_inline_vr_poses", PAGE_LOAD_TIMEOUT_S);
         NfcSimUtils.simNfcScanUntilVrEntry(mTestRule.getActivity());
 
         mWebXrVrTestFramework.enterMagicWindowSessionWithUserGestureOrFail();
@@ -169,9 +166,8 @@ public class WebXrVrDeviceTest {
     @MinAndroidSdkLevel(Build.VERSION_CODES.LOLLIPOP) // WebXR is only supported on L+
     public void testForNullPosesInInlineVrOnNavigation() {
         NfcSimUtils.simNfcScanUntilVrEntry(mTestRule.getActivity());
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_inline_vr_poses"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_inline_vr_poses", PAGE_LOAD_TIMEOUT_S);
 
         mWebXrVrTestFramework.enterMagicWindowSessionWithUserGestureOrFail();
         mWebXrVrTestFramework.executeStepAndWait("posesTurnedOffStep()");

chrome/android/javatests/src/org/chromium/chrome/browser/vr/WebXrVrInputTest.java

@@ -104,14 +104,12 @@ public class WebXrVrInputTest {
             @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
             public void
             testScreenTapsNotRegistered_WebXr() throws InterruptedException {
-        screenTapsNotRegisteredImpl(WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                                            "webxr_test_screen_taps_not_registered"),
-                mWebXrVrTestFramework);
+        screenTapsNotRegisteredImpl("webxr_test_screen_taps_not_registered", mWebXrVrTestFramework);
     }
 
     private void screenTapsNotRegisteredImpl(String url, final WebXrVrTestFramework framework)
             throws InterruptedException {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.executeStepAndWait("stepVerifyNoInitialTaps()");
         framework.enterSessionWithUserGestureOrFail();
         VrTransitionUtils.waitForOverlayGone();
@@ -143,9 +141,8 @@ public class WebXrVrInputTest {
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testControllerClicksRegisteredOnDaydream_WebXr() {
         EmulatedVrController controller = new EmulatedVrController(mTestRule.getActivity());
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_webxr_input"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_webxr_input", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.enterSessionWithUserGestureOrFail();
 
         int numIterations = 10;
@@ -177,9 +174,8 @@ public class WebXrVrInputTest {
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testControllerExposedAsGamepadOnDaydream_WebXr() {
         EmulatedVrController controller = new EmulatedVrController(mTestRule.getActivity());
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_webxr_gamepad_support"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_webxr_gamepad_support", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.enterSessionWithUserGestureOrFail();
 
         // There must be interaction with the controller before an XRInputSource
@@ -292,9 +288,8 @@ public class WebXrVrInputTest {
     @CommandLineFlags.Add({"enable-features=WebXR"})
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testScreenTapsRegisteredOnCardboard_WebXr() {
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_webxr_input"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_webxr_input", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.enterSessionWithUserGestureOrFail();
         // Make it so that the webpage doesn't try to finish the JavaScript step after each input
         // since we don't need to ack each one like with the Daydream controller.
@@ -328,9 +323,8 @@ public class WebXrVrInputTest {
     @CommandLineFlags.Add({"enable-features=WebXR"})
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testTransientScreenTapsRegisteredOnCardboard_WebXr() {
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_webxr_transient_input"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_webxr_transient_input", PAGE_LOAD_TIMEOUT_S);
         // Make it so that the webpage doesn't try to finish the JavaScript step after each input
         // since we don't need to ack each one like with the Daydream controller.
         mWebXrVrTestFramework.runJavaScriptOrFail(
@@ -359,20 +353,18 @@ public class WebXrVrInputTest {
     @CommandLineFlags.Add({"enable-features=WebXR"})
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     public void testPresentationLocksFocus_WebXr() {
-        presentationLocksFocusImpl(WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                                           "webxr_test_presentation_locks_focus"),
-                mWebXrVrTestFramework);
+        presentationLocksFocusImpl("webxr_test_presentation_locks_focus", mWebXrVrTestFramework);
     }
 
     private void presentationLocksFocusImpl(String url, WebXrVrTestFramework framework) {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.enterSessionWithUserGestureOrFail();
         framework.executeStepAndWait("stepSetupFocusLoss()");
         framework.endTest();
     }
 
     private void appButtonExitsPresentationImpl(String url, WebXrVrTestFramework framework) {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.enterSessionWithUserGestureOrFail();
         NativeUiUtils.clickAppButton(UserFriendlyElementName.NONE, new PointF());
         assertAppButtonEffect(true /* shouldHaveExited */, framework);
@@ -389,8 +381,7 @@ public class WebXrVrInputTest {
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
     @CommandLineFlags.Add({"enable-features=WebXR"})
     public void testAppButtonNoopsWhenBrowsingDisabled_WebXr() throws ExecutionException {
-        appButtonNoopsTestImpl(WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                mWebXrVrTestFramework);
+        appButtonNoopsTestImpl("generic_webxr_page", mWebXrVrTestFramework);
     }
 
     /**
@@ -405,14 +396,13 @@ public class WebXrVrInputTest {
     @CommandLineFlags.Add({"enable-features=WebXR"})
     public void
     testAppButtonNoopsWhenBrowsingNotSupported_WebXr() throws ExecutionException {
-        appButtonNoopsTestImpl(WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                mWebXrVrTestFramework);
+        appButtonNoopsTestImpl("generic_webxr_page", mWebXrVrTestFramework);
     }
 
     private void appButtonNoopsTestImpl(String url, WebXrVrTestFramework framework)
             throws ExecutionException {
         VrShellDelegateUtils.getDelegateInstance().setVrBrowsingDisabled(true);
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.enterSessionWithUserGestureOrFail();
 
         MockVrDaydreamApi mockApi = new MockVrDaydreamApi();
@@ -441,13 +431,11 @@ public class WebXrVrInputTest {
     @Restriction(RESTRICTION_TYPE_VIEWER_DAYDREAM_OR_STANDALONE)
     @CommandLineFlags.Add({"enable-features=WebXR"})
     public void testAppButtonAfterPageStopsSubmitting_WebXr() {
-        appButtonAfterPageStopsSubmittingImpl(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("webxr_page_submits_once"),
-                mWebXrVrTestFramework);
+        appButtonAfterPageStopsSubmittingImpl("webxr_page_submits_once", mWebXrVrTestFramework);
     }
 
     private void appButtonAfterPageStopsSubmittingImpl(String url, WebXrVrTestFramework framework) {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.enterSessionWithUserGestureOrFail();
         // Wait for page to stop submitting frames.
         framework.waitOnJavaScriptStep();
@@ -485,9 +473,8 @@ public class WebXrVrInputTest {
     }
 
     private void webxrGamepadSupportImpl(boolean daydream) {
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("test_webxr_gamepad_support"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_webxr_gamepad_support", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.enterSessionWithUserGestureOrFail();
 
         // Spam input to make sure the Gamepad API registers the gamepad if it should.
@@ -548,10 +535,8 @@ public class WebXrVrInputTest {
     private void testAppButtonLongPressDisplaysPermissionsImpl() throws InterruptedException {
         // Note that we need to pass in the WebContents to use throughout this because automatically
         // using the first tab's WebContents doesn't work in Incognito.
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                mWebXrVrTestFramework.getEmbeddedServerUrlForHtmlTestFile(
-                        "generic_webxr_permission_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "generic_webxr_permission_page", PAGE_LOAD_TIMEOUT_S);
         WebXrVrTestFramework.runJavaScriptOrFail("requestPermission({audio:true})",
                 POLL_TIMEOUT_SHORT_MS, mTestRule.getWebContents());
 
@@ -630,10 +615,8 @@ public class WebXrVrInputTest {
     private void testInSessionPermissionRequestsImpl() {
         // Note that we need to pass in the WebContents to use throughout this because automatically
         // using the first tab's WebContents doesn't work in Incognito.
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                mWebXrVrTestFramework.getEmbeddedServerUrlForHtmlTestFile(
-                        "generic_webxr_permission_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "generic_webxr_permission_page", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.enterSessionWithUserGestureOrFail(mTestRule.getWebContents());
         NativeUiUtils.enableMockedInput();
         NativeUiUtils.performActionAndWaitForVisibilityStatus(

chrome/android/javatests/src/org/chromium/chrome/browser/vr/WebXrVrTabTest.java

@@ -74,13 +74,11 @@ public class WebXrVrTabTest {
     @Restriction(RESTRICTION_TYPE_SVR)
             @CommandLineFlags.Add({"enable-features=WebXR"})
             public void testPoseDataUnfocusedTab_WebXr() {
-        testPoseDataUnfocusedTabImpl(WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                                             "webxr_test_pose_data_unfocused_tab"),
-                mWebXrVrTestFramework);
+        testPoseDataUnfocusedTabImpl("webxr_test_pose_data_unfocused_tab", mWebXrVrTestFramework);
     }
 
     private void testPoseDataUnfocusedTabImpl(String url, WebXrVrTestFramework framework) {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.executeStepAndWait("stepCheckFrameDataWhileFocusedTab()");
         WebContents firstTabContents = framework.getCurrentWebContents();
 
@@ -112,10 +110,8 @@ public class WebXrVrTabTest {
     }
 
     private void testPermissionsInOtherTabImpl(boolean incognito) throws InterruptedException {
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                mWebXrVrTestFramework.getEmbeddedServerUrlForHtmlTestFile(
-                        "generic_webxr_permission_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "generic_webxr_permission_page", PAGE_LOAD_TIMEOUT_S);
         // Be sure to store the stream we're given so that the permission is actually in use, as
         // otherwise the toast doesn't show up since another tab isn't actually using the
         // permission.
@@ -143,9 +139,8 @@ public class WebXrVrTabTest {
             mTestRule.loadUrlInNewTab("about:blank");
         }
 
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "generic_webxr_page", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.enterSessionWithUserGestureOrFail();
         NativeUiUtils.performActionAndWaitForVisibilityStatus(
                 UserFriendlyElementName.WEB_XR_AUDIO_INDICATOR, true /* visible */, () -> {});

chrome/android/javatests/src/org/chromium/chrome/browser/vr/WebXrVrTransitionTest.java

@@ -97,13 +97,11 @@ public class WebXrVrTransitionTest {
             @CommandLineFlags.Add({"enable-features=WebXR"})
             @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
             public void testRequestSessionEntersVr() {
-        testPresentationEntryImpl(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                mWebXrVrTestFramework);
+        testPresentationEntryImpl("generic_webxr_page", mWebXrVrTestFramework);
     }
 
     private void testPresentationEntryImpl(String url, WebXrVrTestFramework framework) {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.enterSessionWithUserGestureOrFail();
         Assert.assertTrue("Browser did not enter VR", VrShellDelegate.isInVr());
 
@@ -150,13 +148,12 @@ public class WebXrVrTransitionTest {
             .Add({"disable-features=WebXR"})
             @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
             public void testWebXrDisabledWithoutFlagSet() {
-        apiDisabledWithoutFlagSetImpl(WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                                              "test_webxr_disabled_without_flag_set"),
-                mWebXrVrTestFramework);
+        apiDisabledWithoutFlagSetImpl(
+                "test_webxr_disabled_without_flag_set", mWebXrVrTestFramework);
     }
 
     private void apiDisabledWithoutFlagSetImpl(String url, WebXrVrTestFramework framework) {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.waitOnJavaScriptStep();
         framework.endTest();
     }
@@ -173,14 +170,13 @@ public class WebXrVrTransitionTest {
             @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
             public void testPresentationPromiseUnresolvedDuringDon_WebXr() {
         presentationPromiseUnresolvedDuringDonImpl(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                        "webxr_test_presentation_promise_unresolved_during_don"),
-                mWebXrVrTestFramework);
+
+                "webxr_test_presentation_promise_unresolved_during_don", mWebXrVrTestFramework);
     }
 
     private void presentationPromiseUnresolvedDuringDonImpl(
             String url, WebXrVrTestFramework framework) {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.enterSessionWithUserGestureAndWait();
         framework.endTest();
     }
@@ -196,14 +192,13 @@ public class WebXrVrTransitionTest {
             @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
             public void testPresentationPromiseRejectedIfDonCanceled_WebXr() {
         presentationPromiseRejectedIfDonCanceledImpl(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                        "webxr_test_presentation_promise_rejected_if_don_canceled"),
-                mWebXrVrTestFramework);
+
+                "webxr_test_presentation_promise_rejected_if_don_canceled", mWebXrVrTestFramework);
     }
 
     private void presentationPromiseRejectedIfDonCanceledImpl(
             String url, WebXrVrTestFramework framework) {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         final UiDevice uiDevice =
                 UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
         framework.enterSessionWithUserGesture();
@@ -226,14 +221,12 @@ public class WebXrVrTransitionTest {
             @CommandLineFlags.Add({"enable-features=WebXR"})
             @Restriction(RESTRICTION_TYPE_SVR)
             public void testControlsVisibleAfterExitingVr_WebXr() throws InterruptedException {
-        controlsVisibleAfterExitingVrImpl(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                mWebXrVrTestFramework);
+        controlsVisibleAfterExitingVrImpl("generic_webxr_page", mWebXrVrTestFramework);
     }
 
     private void controlsVisibleAfterExitingVrImpl(String url, final WebXrVrTestFramework framework)
             throws InterruptedException {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.enterSessionWithUserGestureOrFail();
         VrTransitionUtils.forceExitVr();
         // The hiding of the controls may only propagate after VR has exited, so give it a chance
@@ -262,14 +255,14 @@ public class WebXrVrTransitionTest {
             public void testWindowRafStopsFiringWhilePresenting_WebXr()
             throws InterruptedException {
         windowRafStopsFiringWhilePresentingImpl(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                        "webxr_test_window_raf_stops_firing_during_immersive_session"),
+
+                "webxr_test_window_raf_stops_firing_during_immersive_session",
                 mWebXrVrTestFramework);
     }
 
     private void windowRafStopsFiringWhilePresentingImpl(String url, WebXrVrTestFramework framework)
             throws InterruptedException {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.executeStepAndWait("stepVerifyBeforePresent()");
         // Pausing of window.rAF is done asynchronously, so wait until that's done.
         final CountDownLatch vsyncPausedLatch = new CountDownLatch(1);
@@ -291,13 +284,11 @@ public class WebXrVrTransitionTest {
     @Restriction(RESTRICTION_TYPE_VIEWER_DAYDREAM_OR_STANDALONE)
             @CommandLineFlags.Add({"enable-features=WebXR"})
             public void testRendererKilledInWebXrStaysInVr() throws IllegalArgumentException {
-        rendererKilledInVrStaysInVrImpl(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                mWebXrVrTestFramework);
+        rendererKilledInVrStaysInVrImpl("generic_webxr_page", mWebXrVrTestFramework);
     }
 
     private void rendererKilledInVrStaysInVrImpl(String url, WebXrVrTestFramework framework) {
-        framework.loadUrlAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
+        framework.loadFileAndAwaitInitialization(url, PAGE_LOAD_TIMEOUT_S);
         framework.enterSessionWithUserGestureOrFail();
         framework.simulateRendererKilled();
         Assert.assertTrue("Browser did not enter VR", VrShellDelegate.isInVr());
@@ -312,10 +303,8 @@ public class WebXrVrTransitionTest {
             @CommandLineFlags.Add({"enable-features=WebXR"})
             @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
             public void testWindowRafFiresDuringNonImmersiveSession() {
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                        "test_window_raf_fires_during_non_immersive_session"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_window_raf_fires_during_non_immersive_session", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.waitOnJavaScriptStep();
         mWebXrVrTestFramework.endTest();
     }
@@ -330,10 +319,8 @@ public class WebXrVrTransitionTest {
             @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
             @DisableFeatures(ChromeFeatureList.SEND_TAB_TO_SELF)
             public void testNonImmersiveStopsDuringImmersive() {
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile(
-                        "test_non_immersive_stops_during_immersive"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "test_non_immersive_stops_during_immersive", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.executeStepAndWait("stepBeforeImmersive()");
         mWebXrVrTestFramework.enterSessionWithUserGestureOrFail();
         mWebXrVrTestFramework.executeStepAndWait("stepDuringImmersive()");
@@ -352,9 +339,8 @@ public class WebXrVrTransitionTest {
             @CommandLineFlags.Add({"enable-features=WebXR"})
             @XrActivityRestriction({XrActivityRestriction.SupportedActivity.CTA})
             public void testAppButtonExitToast() {
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "generic_webxr_page", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.enterSessionWithUserGestureOrFail();
         NativeUiUtils.performActionAndWaitForVisibilityStatus(
                 UserFriendlyElementName.APP_BUTTON_EXIT_TOAST, true /* visible*/, () -> {});
@@ -371,9 +357,8 @@ public class WebXrVrTransitionTest {
             public void testConsentDialogIsDismissedWhenPageNavigatesAwayInMainFrame() {
         mWebXrVrTestFramework.setConsentDialogAction(
                 WebXrVrTestFramework.CONSENT_DIALOG_ACTION_DO_NOTHING);
-        mWebXrVrTestFramework.loadUrlAndAwaitInitialization(
-                WebXrVrTestFramework.getFileUrlForHtmlTestFile("generic_webxr_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mWebXrVrTestFramework.loadFileAndAwaitInitialization(
+                "generic_webxr_page", PAGE_LOAD_TIMEOUT_S);
         mWebXrVrTestFramework.enterSessionWithUserGesture();
         mWebXrVrTestFramework.runJavaScriptOrFail(
                 "window.location.href = 'https://google.com'", POLL_TIMEOUT_SHORT_MS);

chrome/android/javatests/src/org/chromium/chrome/browser/vr/XrTestFramework.java

@@ -11,7 +11,6 @@ import androidx.annotation.IntDef;
 import org.junit.Assert;
 
 import org.chromium.base.Log;
-import org.chromium.base.test.util.UrlUtils;
 import org.chromium.chrome.browser.tab.SadTab;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tab.TabLaunchType;
@@ -84,17 +83,6 @@ public abstract class XrTestFramework {
 
     private ChromeActivityTestRule mRule;
 
-    /**
-     * Gets the file:// URL to the test file.
-     *
-     * @param testName The name of the test whose file will be retrieved.
-     * @return The file:// URL to the specified test file.
-     */
-    public static String getFileUrlForHtmlTestFile(String testName) {
-        return "file://" + UrlUtils.getIsolatedTestFilePath(TEST_DIR) + "/html/" + testName
-                + ".html";
-    }
-
     /**
      * Checks whether a request for the given permission would trigger a permission prompt.
      *
@@ -395,24 +383,27 @@ public abstract class XrTestFramework {
     }
 
     /**
-     * Gets the URL that loads the given test file from the embedded test server.
+     * Gets the URL that loads the given test file from the embedded test server
+     * Note that because sessions may cause permissions prompts to appear, this
+     * uses the embedded server, as granting permissions to file:// URLs results
+     * in DCHECKs.
      *
      * @param testName The name of the test whose file will be retrieved.
      */
-    public String getEmbeddedServerUrlForHtmlTestFile(String testName) {
+    public String getUrlForFile(String testName) {
         return mRule.getTestServer().getURL("/" + TEST_DIR + "/html/" + testName + ".html");
     }
 
     /**
-     * Loads the given URL with the given timeout then waits for JavaScript to
-     * signal that it's ready for testing.
+     * Loads the given file on an embedded server with the given timeout then
+     * waits for JavaScript to signal that it's ready for testing.
      *
-     * @param url The URL of the page to load.
+     * @param file The name of the page to load.
      * @param timeoutSec The timeout of the page load in seconds.
      * @return The return value of ChromeActivityTestRule.loadUrl().
      */
-    public int loadUrlAndAwaitInitialization(String url, int timeoutSec) {
-        int result = mRule.loadUrl(url, timeoutSec);
+    public int loadFileAndAwaitInitialization(String url, int timeoutSec) {
+        int result = mRule.loadUrl(getUrlForFile(url), timeoutSec);
         Assert.assertTrue("Timed out waiting for JavaScript test initialization",
                 pollJavaScriptBoolean("isInitializationComplete()", POLL_TIMEOUT_LONG_MS,
                         mRule.getWebContents()));

chrome/android/javatests/src/org/chromium/chrome/browser/vr/adding_new_tests.md

@@ -27,7 +27,7 @@ For a concrete example, take a look at
 
 The general flow in tests will be:
 
-1. Load the HTML file with loadUrlAndAwaitInitialization - this ensures that any
+1. Load the HTML file with loadFileAndAwaitInitialization - this ensures that any
    pre-test setup in JavaScript is completed.
 2. Run some code on Java's side.
 3. Trigger some JavaScript code and wait for it to signal that it is finished.
@@ -192,4 +192,4 @@ bucket.
 [webxr_vr_transition_test_html]: https://chromium.googlesource.com/chromium/src/+/master/chrome/test/data/xr/e2e_test_files/html/test_non_immersive_stops_during_immersive.html
 [vr_settings_service_utils]: https://chromium.googlesource.com/chromium/src/+/master/chrome/android/javatests/src/org/chromium/chrome/browser/vr/util/VrSettingsServiceUtils.java
 [vr_browser_transition_test]: https://chromium.googlesource.com/chromium/src/+/master/chrome/android/javatests/src/org/chromium/chrome/browser/vr/VrBrowserTransitionTest.java
-[build_gn]: https://chromium.googlesource.com/chromium/src/+/master/chrome/android/BUILD.gn
+[build_gn]: https://chromium.googlesource.com/chromium/src/+/master/chrome/android/BUILD.gn
\ No newline at end of file

chrome/android/javatests/src/org/chromium/chrome/browser/vr/jsdialog/VrBrowserJavaScriptModalDialogTest.java

@@ -55,9 +55,8 @@ public class VrBrowserJavaScriptModalDialogTest {
     public void setUp() {
         mActivity = mActivityTestRule.getActivity();
         mVrBrowserTestFramework = new VrBrowserTestFramework(mActivityTestRule);
-        mVrBrowserTestFramework.loadUrlAndAwaitInitialization(
-                VrBrowserTestFramework.getFileUrlForHtmlTestFile("2d_permission_page"),
-                PAGE_LOAD_TIMEOUT_S);
+        mVrBrowserTestFramework.loadFileAndAwaitInitialization(
+                "2d_permission_page", PAGE_LOAD_TIMEOUT_S);
         VrBrowserTransitionUtils.forceEnterVrBrowserOrFail(POLL_TIMEOUT_LONG_MS);
         NativeUiUtils.enableMockedInput();
         // Wait for any residual animations from entering VR to finish so that they don't get caught