Bug 1472212 - Update URLs to include the noscripts version in xpcshell and browser tests for newtab. draft
authorimjching <jlim@mozilla.com>
Wed, 11 Jul 2018 17:18:21 -0400
changeset 821499 7dd8b26bd37fc767ebfea17af37ebc8a7da9f9cf
parent 821498 bb68a583040d7d23d23ef6bd9b676e12ef77ca5b
child 821500 7c5ddab37d6ec51cf095c7d3e4e7c42f902e7caa
push id117115
push userbmo:jlim@mozilla.com
push dateMon, 23 Jul 2018 13:52:58 +0000
bugs1472212
milestone63.0a1
Bug 1472212 - Update URLs to include the noscripts version in xpcshell and browser tests for newtab. MozReview-Commit-ID: EA4YminghNs
browser/components/newtab/tests/browser/browser_packaged_as_locales.js
browser/components/newtab/tests/xpcshell/test_AboutNewTabService.js
--- a/browser/components/newtab/tests/browser/browser_packaged_as_locales.js
+++ b/browser/components/newtab/tests/browser/browser_packaged_as_locales.js
@@ -1,15 +1,18 @@
 ChromeUtils.import("resource://gre/modules/Services.jsm");
 XPCOMUtils.defineLazyServiceGetter(this, "aboutNewTabService",
                                    "@mozilla.org/browser/aboutnewtab-service;1",
                                    "nsIAboutNewTabService");
 
 // Tests are by default run with non-debug en-US configuration
-const DEFAULT_URL = "resource://activity-stream/prerendered/en-US/activity-stream-prerendered.html";
+const IS_NIGHTLY_BUILD = AppConstants.NIGHTLY_BUILD;
+const DEFAULT_URL = IS_NIGHTLY_BUILD
+  ? "resource://activity-stream/prerendered/en-US/activity-stream-prerendered-noscripts.html"
+  : "resource://activity-stream/prerendered/en-US/activity-stream-prerendered.html";
 
 /**
  * Temporarily change the app locale to get the localized activity stream url
  */
 async function getUrlForLocale(locale) {
   const origAvailable = Services.locale.getAvailableLocales();
   const origRequested = Services.locale.getRequestedLocales();
   try {
--- a/browser/components/newtab/tests/xpcshell/test_AboutNewTabService.js
+++ b/browser/components/newtab/tests/xpcshell/test_AboutNewTabService.js
@@ -10,35 +10,43 @@ ChromeUtils.import("resource://gre/modul
 ChromeUtils.import("resource://gre/modules/AppConstants.jsm");
 XPCOMUtils.defineLazyServiceGetter(this, "aboutNewTabService",
                                    "@mozilla.org/browser/aboutnewtab-service;1",
                                    "nsIAboutNewTabService");
 
 const IS_RELEASE_OR_BETA = AppConstants.RELEASE_OR_BETA;
 
 const ACTIVITY_STREAM_PRERENDER_URL = "resource://activity-stream/prerendered/en-US/activity-stream-prerendered.html";
+const ACTIVITY_STREAM_PRERENDER_NOSCRIPTS_URL = "resource://activity-stream/prerendered/en-US/activity-stream-prerendered-noscripts.html";
 const ACTIVITY_STREAM_PRERENDER_DEBUG_URL = "resource://activity-stream/prerendered/static/activity-stream-prerendered-debug.html";
+const ACTIVITY_STREAM_PRERENDER_DEBUG_NOSCRIPTS_URL = "resource://activity-stream/prerendered/static/activity-stream-prerendered-debug-noscripts.html";
 const ACTIVITY_STREAM_URL = "resource://activity-stream/prerendered/en-US/activity-stream.html";
+const ACTIVITY_STREAM_NOSCRIPTS_URL = "resource://activity-stream/prerendered/en-US/activity-stream-noscripts.html";
 const ACTIVITY_STREAM_DEBUG_URL = "resource://activity-stream/prerendered/static/activity-stream-debug.html";
+const ACTIVITY_STREAM_DEBUG_NOSCRIPTS_URL = "resource://activity-stream/prerendered/static/activity-stream-debug-noscripts.html";
 
 const DOWNLOADS_URL = "chrome://browser/content/downloads/contentAreaDownloadsView.xul";
+const SEPARATE_PRIVILEGED_CONTENT_PROCESS_PREF = "browser.tabs.remote.separatePrivilegedContentProcess";
 const ACTIVITY_STREAM_PRERENDER_PREF = "browser.newtabpage.activity-stream.prerender";
 const ACTIVITY_STREAM_DEBUG_PREF = "browser.newtabpage.activity-stream.debug";
 
 function cleanup() {
+  Services.prefs.clearUserPref(SEPARATE_PRIVILEGED_CONTENT_PROCESS_PREF);
   Services.prefs.clearUserPref(ACTIVITY_STREAM_PRERENDER_PREF);
   Services.prefs.clearUserPref(ACTIVITY_STREAM_DEBUG_PREF);
   aboutNewTabService.resetNewTabURL();
 }
 
 registerCleanupFunction(cleanup);
 
 add_task(async function test_as_and_prerender_initialized() {
   Assert.ok(aboutNewTabService.activityStreamEnabled,
     ".activityStreamEnabled should be set to the correct initial value");
+  Assert.equal(aboutNewTabService.privilegedContentProcess, Services.prefs.getBoolPref(SEPARATE_PRIVILEGED_CONTENT_PROCESS_PREF),
+    ".privilegedContentProcess should be set to the correct initial value");
   Assert.equal(aboutNewTabService.activityStreamPrerender, Services.prefs.getBoolPref(ACTIVITY_STREAM_PRERENDER_PREF),
     ".activityStreamPrerender should be set to the correct initial value");
   // This pref isn't defined on release or beta, so we fall back to false
   Assert.equal(aboutNewTabService.activityStreamDebug, Services.prefs.getBoolPref(ACTIVITY_STREAM_DEBUG_PREF, false),
     ".activityStreamDebug should be set to the correct initial value");
 });
 
 /**
@@ -68,140 +76,168 @@ add_task(async function test_override_ac
   aboutNewTabService.newTabURL = DOWNLOADS_URL;
   await notificationPromise;
   Assert.ok(aboutNewTabService.overridden, "Newtab URL should be overridden");
   Assert.equal(aboutNewTabService.newTabURL, DOWNLOADS_URL, "Newtab URL should be the custom URL");
 
   cleanup();
 });
 
-add_task(async function test_override_activity_stream_enabled() {
+async function test_override_activity_stream_enabled(usePrivilegedContentProcess) {
   let notificationPromise = await setupASPrerendered();
+  await setPrivilegedContentProcessPref(usePrivilegedContentProcess);
 
-  Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_PRERENDER_URL, "Newtab URL should be the default activity stream prerendered URL");
+  Assert.equal(aboutNewTabService.defaultURL,
+    usePrivilegedContentProcess ? ACTIVITY_STREAM_PRERENDER_NOSCRIPTS_URL : ACTIVITY_STREAM_PRERENDER_URL,
+    "Newtab URL should be the default activity stream prerendered URL");
   Assert.ok(!aboutNewTabService.overridden, "Newtab URL should not be overridden");
   Assert.ok(aboutNewTabService.activityStreamEnabled, "Activity Stream should be enabled");
   Assert.ok(aboutNewTabService.activityStreamPrerender, "Activity Stream should be prerendered");
 
   // change to a chrome URL while activity stream is enabled
   notificationPromise = nextChangeNotificationPromise(DOWNLOADS_URL);
   aboutNewTabService.newTabURL = DOWNLOADS_URL;
   await notificationPromise;
   Assert.equal(aboutNewTabService.newTabURL, DOWNLOADS_URL,
                "Newtab URL set to chrome url");
-  Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_PRERENDER_URL,
+  Assert.equal(aboutNewTabService.defaultURL,
+               usePrivilegedContentProcess ? ACTIVITY_STREAM_PRERENDER_NOSCRIPTS_URL : ACTIVITY_STREAM_PRERENDER_URL,
                "Newtab URL defaultURL still set to the default activity stream prerendered URL");
   Assert.ok(aboutNewTabService.overridden, "Newtab URL should be overridden");
   Assert.ok(!aboutNewTabService.activityStreamEnabled, "Activity Stream should not be enabled");
 
   cleanup();
-});
+}
+
+add_task(test_override_activity_stream_enabled.bind(this, false));
+add_task(test_override_activity_stream_enabled.bind(this, true));
 
-add_task(async function test_default_url() {
+async function test_default_url(usePrivilegedContentProcess) {
   await setupASPrerendered();
-  Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_PRERENDER_URL,
+  await setPrivilegedContentProcessPref(usePrivilegedContentProcess);
+
+  Assert.equal(aboutNewTabService.defaultURL,
+    usePrivilegedContentProcess ? ACTIVITY_STREAM_PRERENDER_NOSCRIPTS_URL : ACTIVITY_STREAM_PRERENDER_URL,
     "Newtab defaultURL initially set to prerendered AS url");
 
   // Only debug variants aren't available on release/beta
   if (!IS_RELEASE_OR_BETA) {
     await setBoolPrefAndWaitForChange(ACTIVITY_STREAM_DEBUG_PREF, true,
       "A notification occurs after changing the debug pref to true");
     Assert.equal(aboutNewTabService.activityStreamDebug, true,
       "the .activityStreamDebug property is set to true");
-    Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_PRERENDER_DEBUG_URL,
+    Assert.equal(aboutNewTabService.defaultURL,
+      usePrivilegedContentProcess ? ACTIVITY_STREAM_PRERENDER_DEBUG_NOSCRIPTS_URL : ACTIVITY_STREAM_PRERENDER_DEBUG_URL,
       "Newtab defaultURL set to debug prerendered AS url after the pref has been changed");
     await setBoolPrefAndWaitForChange(ACTIVITY_STREAM_PRERENDER_PREF, false,
       "A notification occurs after changing the prerender pref to false");
-    Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_DEBUG_URL,
+    Assert.equal(aboutNewTabService.defaultURL,
+      usePrivilegedContentProcess ? ACTIVITY_STREAM_DEBUG_NOSCRIPTS_URL : ACTIVITY_STREAM_DEBUG_URL,
       "Newtab defaultURL set to un-prerendered AS with debug if prerender is false and debug is true");
     await setBoolPrefAndWaitForChange(ACTIVITY_STREAM_DEBUG_PREF, false,
       "A notification occurs after changing the debug pref to false");
   } else {
     Services.prefs.setBoolPref(ACTIVITY_STREAM_DEBUG_PREF, true);
 
     Assert.equal(aboutNewTabService.activityStreamDebug, false,
       "the .activityStreamDebug property is remains false");
     await setBoolPrefAndWaitForChange(ACTIVITY_STREAM_PRERENDER_PREF, false,
       "A notification occurs after changing the prerender pref to false");
   }
 
-  Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_URL,
+  Assert.equal(aboutNewTabService.defaultURL,
+    usePrivilegedContentProcess ? ACTIVITY_STREAM_NOSCRIPTS_URL : ACTIVITY_STREAM_URL,
     "Newtab defaultURL set to un-prerendered AS if prerender is false and debug is false");
 
   cleanup();
-});
+}
 
-add_task(async function test_welcome_url() {
+add_task(test_default_url.bind(this, false));
+add_task(test_default_url.bind(this, true));
+
+async function test_welcome_url(usePrivilegedContentProcess) {
   await setupASPrerendered();
+  await setPrivilegedContentProcessPref(usePrivilegedContentProcess);
 
   Assert.equal(aboutNewTabService.activityStreamPrerender, true,
     "Prerendering is enabled by default.");
-  Assert.equal(aboutNewTabService.welcomeURL, ACTIVITY_STREAM_URL,
+  Assert.equal(aboutNewTabService.welcomeURL,
+    usePrivilegedContentProcess ? ACTIVITY_STREAM_NOSCRIPTS_URL : ACTIVITY_STREAM_URL,
     "Newtab welcomeURL set to un-prerendered AS when prerendering enabled and debug disabled.");
   await setBoolPrefAndWaitForChange(ACTIVITY_STREAM_PRERENDER_PREF, false,
     "A notification occurs after changing the prerender pref to false.");
   Assert.equal(aboutNewTabService.welcomeURL, aboutNewTabService.defaultURL,
     "Newtab welcomeURL is equal to defaultURL when prerendering disabled and debug disabled.");
 
   // Only debug variants aren't available on release/beta
   if (!IS_RELEASE_OR_BETA) {
     await setBoolPrefAndWaitForChange(ACTIVITY_STREAM_DEBUG_PREF, true,
       "A notification occurs after changing the debug pref to true.");
     Assert.equal(aboutNewTabService.welcomeURL, aboutNewTabService.welcomeURL,
       "Newtab welcomeURL is equal to defaultURL when prerendering disabled and debug enabled.");
     await setBoolPrefAndWaitForChange(ACTIVITY_STREAM_PRERENDER_PREF, true,
       "A notification occurs after changing the prerender pref to true.");
-    Assert.equal(aboutNewTabService.welcomeURL, ACTIVITY_STREAM_DEBUG_URL,
+    Assert.equal(aboutNewTabService.welcomeURL,
+      usePrivilegedContentProcess ? ACTIVITY_STREAM_DEBUG_NOSCRIPTS_URL : ACTIVITY_STREAM_DEBUG_URL,
       "Newtab welcomeURL set to un-prerendered debug AS when prerendering enabled and debug enabled");
   }
 
   cleanup();
-});
+}
+
+add_task(test_welcome_url.bind(this, false));
+add_task(test_welcome_url.bind(this, true));
 
 add_task(function test_locale() {
   Assert.equal(aboutNewTabService.activityStreamLocale, "en-US",
     "The locale for testing should be en-US");
 });
 
 /**
  * Tests reponse to updates to prefs
  */
-add_task(async function test_updates() {
+async function test_updates(usePrivilegedContentProcess) {
   /*
    * Simulates a "cold-boot" situation, with some pref already set before testing a series
    * of changes.
    */
   await setupASPrerendered();
+  await setPrivilegedContentProcessPref(usePrivilegedContentProcess);
 
   aboutNewTabService.resetNewTabURL(); // need to set manually because pref notifs are off
   let notificationPromise;
 
   // test update fires on override and reset
   let testURL = "https://example.com/";
   notificationPromise = nextChangeNotificationPromise(
     testURL, "a notification occurs on override");
   aboutNewTabService.newTabURL = testURL;
   await notificationPromise;
 
   // from overridden to default
   notificationPromise = nextChangeNotificationPromise(
     "about:newtab", "a notification occurs on reset");
   aboutNewTabService.resetNewTabURL();
   Assert.ok(aboutNewTabService.activityStreamEnabled, "Activity Stream should be enabled");
-  Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_PRERENDER_URL, "Default URL should be the activity stream page");
+  Assert.equal(aboutNewTabService.defaultURL,
+    usePrivilegedContentProcess ? ACTIVITY_STREAM_PRERENDER_NOSCRIPTS_URL : ACTIVITY_STREAM_PRERENDER_URL,
+    "Default URL should be the activity stream page");
   await notificationPromise;
 
   // reset twice, only one notification for default URL
   notificationPromise = nextChangeNotificationPromise(
     "about:newtab", "reset occurs");
   aboutNewTabService.resetNewTabURL();
   await notificationPromise;
 
   cleanup();
-});
+}
+
+add_task(test_updates.bind(this, false));
+add_task(test_updates.bind(this, true));
 
 function nextChangeNotificationPromise(aNewURL, testMessage) {
   return new Promise(resolve => {
     Services.obs.addObserver(function observer(aSubject, aTopic, aData) { // jshint unused:false
       Services.obs.removeObserver(observer, aTopic);
       Assert.equal(aData, aNewURL, testMessage);
       resolve();
     }, "newtab-url-changed");
@@ -215,18 +251,27 @@ function setBoolPrefAndWaitForChange(pre
       Assert.equal(aData, aboutNewTabService.newTabURL, testMessage);
       resolve();
     }, "newtab-url-changed");
 
     Services.prefs.setBoolPref(pref, value);
   });
 }
 
-
 function setupASPrerendered() {
   if (Services.prefs.getBoolPref(ACTIVITY_STREAM_PRERENDER_PREF)) {
     return Promise.resolve();
   }
 
   let notificationPromise = nextChangeNotificationPromise("about:newtab");
   Services.prefs.setBoolPref(ACTIVITY_STREAM_PRERENDER_PREF, true);
   return notificationPromise;
 }
+
+function setPrivilegedContentProcessPref(usePrivilegedContentProcess) {
+  if (usePrivilegedContentProcess === Services.prefs.getBoolPref(SEPARATE_PRIVILEGED_CONTENT_PROCESS_PREF)) {
+    return Promise.resolve();
+  }
+
+  let notificationPromise = nextChangeNotificationPromise("about:newtab");
+  Services.prefs.setBoolPref(SEPARATE_PRIVILEGED_CONTENT_PROCESS_PREF, usePrivilegedContentProcess);
+  return notificationPromise;
+}