tor-browser

head.js (6265B)

---

/* Any copyright is dedicated to the Public Domain.
  http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

ChromeUtils.defineESModuleGetters(this, {
 NetworkHelper:
   "resource://devtools/shared/network-observer/NetworkHelper.sys.mjs",
 NetworkObserver:
   "resource://devtools/shared/network-observer/NetworkObserver.sys.mjs",
 NetworkUtils:
   "resource://devtools/shared/network-observer/NetworkUtils.sys.mjs",
});

const TEST_DIR = gTestPath.substr(0, gTestPath.lastIndexOf("/"));
const CHROME_URL_ROOT = TEST_DIR + "/";
const URL_ROOT = CHROME_URL_ROOT.replace(
 "chrome://mochitests/content/",
 "https://example.com/"
);

/**
* Load the provided url in an existing browser.
* Returns a promise which will resolve when the page is loaded.
*
* @param {Browser} browser
*     The browser element where the URL should be loaded.
* @param {string} url
*     The URL to load in the new tab
*/
async function loadURL(browser, url) {
 const loaded = BrowserTestUtils.browserLoaded(browser);
 BrowserTestUtils.startLoadingURIString(browser, url);
 return loaded;
}

/**
* Create a new foreground tab loading the provided url.
* Returns a promise which will resolve when the page is loaded.
*
* @param {string} url
*     The URL to load in the new tab
*/
async function addTab(url) {
 const tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url);
 registerCleanupFunction(() => {
   gBrowser.removeTab(tab);
 });
 return tab;
}

/**
* Base network event owner class implementing all mandatory callbacks and
* keeping track of which callbacks have been called.
*/
class NetworkEventOwner {
 hasCacheDetails = false;
 hasEventTimings = false;
 hasRawHeaders = false;
 hasResponseCache = false;
 hasResponseContent = false;
 hasResponseContentComplete = false;
 hasResponseStart = false;
 hasSecurityInfo = false;
 hasServerTimings = false;

 addCacheDetails() {
   this.hasCacheDetails = true;
 }
 addEventTimings() {
   this.hasEventTimings = true;
 }
 addRawHeaders() {
   this.hasRawHeaders = true;
 }
 addResponseCache() {
   this.hasResponseCache = true;
 }
 addResponseContent() {
   this.hasResponseContent = true;
 }
 addResponseContentComplete() {
   this.hasResponseContentComplete = true;
 }
 addResponseStart() {
   this.hasResponseStart = true;
 }
 addSecurityInfo() {
   this.hasSecurityInfo = true;
 }
 addServerTimings() {
   this.hasServerTimings = true;
 }
 addServiceWorkerTimings() {
   this.hasServiceWorkerTimings = true;
 }
}

/**
* Create a simple network event owner, with mock implementations of all
* the expected APIs for a NetworkEventOwner.
*/
function createNetworkEventOwner() {
 return new NetworkEventOwner();
}

/**
* Wait for network events matching the provided URL, until the count reaches
* the provided expected count.
*
* @param {string|null} expectedUrl
*     The URL which should be monitored by the NetworkObserver.If set to null watch for
*      all requests
* @param {number} expectedRequestsCount
*     How many different events (requests) are expected.
* @returns {Promise}
*     A promise which will resolve with an array of network event owners, when
*     the expected event count is reached.
*/
async function waitForNetworkEvents(expectedUrl = null, expectedRequestsCount) {
 const events = [];
 const networkObserver = new NetworkObserver({
   ignoreChannelFunction: channel =>
     expectedUrl ? channel.URI.spec !== expectedUrl : false,
   onNetworkEvent: () => {
     info("waitForNetworkEvents received a new event");
     const owner = createNetworkEventOwner();
     events.push(owner);
     return owner;
   },
 });
 registerCleanupFunction(() => networkObserver.destroy());

 info("Wait until the events count reaches " + expectedRequestsCount);
 await BrowserTestUtils.waitForCondition(
   () => events.length >= expectedRequestsCount
 );
 return events;
}

/**
* NetworkEventOwner class which can be used to assert the response content of
* a network event.
*/
class ResponseContentOwner extends NetworkEventOwner {
 addResponseContent(response) {
   super.addResponseContent();
   this.compressionEncodings = response.compressionEncodings;
   this.contentCharset = response.contentCharset;
   this.decodedBodySize = response.decodedBodySize;
   this.encodedBodySize = response.encodedBodySize;
   this.encodedData = response.encodedData;
   this.encoding = response.encoding;
   this.isContentEncoded = response.isContentEncoded;
   this.text = response.text;
 }

 addResponseContentComplete({ truncated }) {
   super.addResponseContentComplete();
   this.truncated = truncated;
 }

 /**
  * Simple helper to decode the content of a response from a network event.
  */
 async getDecodedContent() {
   if (!this.isContentEncoded) {
     // If the content is not encoded we can directly return the text property.
     return this.text;
   }

   // Otherwise call the dedicated NetworkUtils decodeResponseChunks helper.
   return NetworkUtils.decodeResponseChunks(this.encodedData, {
     charset: this.contentCharset,
     compressionEncodings: this.compressionEncodings,
     encodedBodySize: this.encodedBodySize,
     encoding: this.encoding,
   });
 }
}

/**
* Helper to compress a string using gzip.
*/
function gzipCompressString(string) {
 return new Promise(resolve => {
   const observer = {
     onStreamComplete(loader, context, status, length, result) {
       resolve(String.fromCharCode.apply(this, result));
     },
   };

   const scs = Cc["@mozilla.org/streamConverters;1"].getService(
     Ci.nsIStreamConverterService
   );
   const listener = Cc["@mozilla.org/network/stream-loader;1"].createInstance(
     Ci.nsIStreamLoader
   );
   listener.init(observer);
   const converter = scs.asyncConvertData(
     "uncompressed",
     "gzip",
     listener,
     null
   );
   const stringStream = Cc[
     "@mozilla.org/io/string-input-stream;1"
   ].createInstance(Ci.nsIStringInputStream);
   stringStream.setByteStringData(string);
   converter.onStartRequest(null, null);
   converter.onDataAvailable(null, stringStream, 0, string.length);
   converter.onStopRequest(null, null, null);
 });
}