tor-browser

head.js (7245B)

---

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

"use strict";

const { NetUtil } = ChromeUtils.importESModule(
 "resource://gre/modules/NetUtil.sys.mjs"
);
const { MockRegistrar } = ChromeUtils.importESModule(
 "resource://testing-common/MockRegistrar.sys.mjs"
);
const { MozCachedOHTTPProtocolHandler } = ChromeUtils.importESModule(
 "moz-src:///browser/components/mozcachedohttp/MozCachedOHTTPProtocolHandler.sys.mjs"
);

do_get_profile();

ChromeUtils.registerProcessActor("MozCachedOHTTP", {
 parent: {
   esModuleURI:
     "moz-src:///browser/components/mozcachedohttp/actors/MozCachedOHTTPParent.sys.mjs",
 },
 includeParent: true,
});

/**
* Creates a test URI for the moz-cached-ohttp protocol.
*
* @param {string} resourceURL - The target resource URL to encode
* @returns {string} The moz-cached-ohttp:// URI
*/
function createTestOHTTPResourceURI(resourceURL) {
 const encodedURL = encodeURIComponent(resourceURL);
 return `moz-cached-ohttp://newtab-image/?url=${encodedURL}`;
}

/**
* Creates a test channel with proper load info for privileged about content.
* Always creates a MozCachedOHTTPChannel with the injected mock service.
*
* @param {string} uri - The URI to create a channel for
* @returns {nsIChannel} The created channel
*/
function createTestChannel(uri) {
 const testURI = Services.io.newURI(uri);
 const principal = Services.scriptSecurityManager.getSystemPrincipal();
 const protocolHandler = new MozCachedOHTTPProtocolHandler();
 protocolHandler.injectOHTTPService(MockOHTTPService);

 const loadInfo = createLoadInfo(
   testURI,
   principal,
   Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT,
   Ci.nsIContentPolicy.TYPE_OTHER
 );

 return protocolHandler.newChannel(testURI, loadInfo);
}

/**
* Creates a LoadInfo object for testing using the NetUtil.newChannel pattern.
*
* @param {nsIURI} uri - The URI to use for the temporary channel
* @param {nsIPrincipal} loadingPrincipal - The loading principal
* @param {number} securityFlags - Security flags
* @param {number} contentPolicyType - Content policy type
* @returns {nsILoadInfo} LoadInfo object
*/
function createLoadInfo(
 uri,
 loadingPrincipal,
 securityFlags,
 contentPolicyType
) {
 return NetUtil.newChannel({
   uri,
   loadingPrincipal,
   securityFlags,
   contentPolicyType,
 }).loadInfo;
}

/**
* Creates a reusable data collecting listener for testing channel responses.
*
* @param {Function} onComplete
*   Callback executed on completion with (data, success).
* @returns {nsIStreamListener}
*   Stream listener implementation
*/
function createDataCollectingListener(onComplete) {
 let receivedData = "";

 return {
   onStartRequest() {},

   onDataAvailable(request, inputStream, offset, count) {
     const binaryInputStream = Cc[
       "@mozilla.org/binaryinputstream;1"
     ].createInstance(Ci.nsIBinaryInputStream);
     binaryInputStream.setInputStream(inputStream);
     receivedData += binaryInputStream.readBytes(count);
   },

   onStopRequest(request, status) {
     const success = Components.isSuccessCode(status);
     onComplete(receivedData, success);
   },
 };
}

/**
* Creates a simple completion listener for testing channel success/failure.
*
* @param {Function} onComplete
*   Callback executed on completion with (success).
* @returns {nsIStreamListener}
*   Stream listener implementation
*/
function createCompletionListener(onComplete) {
 let receivedData = false;

 return {
   onStartRequest() {},

   onDataAvailable() {
     receivedData = true;
   },

   onStopRequest(request, status) {
     const success = Components.isSuccessCode(status);
     onComplete(success, receivedData);
   },
 };
}

/**
* Mock OHTTP service for testing.
* Simulates nsIObliviousHttpService behavior for protocol handler testing.
*/
const MockOHTTPService = {
 channelCreated: false,
 totalChannels: 0,
 lastRelayURI: null,
 lastTargetURI: null,
 lastConfig: null,
 shouldSucceed: true,
 shouldUseContentTypeHeader: "",

 /**
  * Creates a mock channel that simulates OHTTP behavior.
  *
  * @param {nsIURI} relayURI
  *   The OHTTP relay URI.
  * @param {nsIURI} targetURI
  *   The target resource URI.
  * @param {Uint8Array} config
  *   OHTTP configuration.
  * @returns {nsIChannel}
  *   Mock channel implementation.
  */
 newChannel(relayURI, targetURI, config) {
   this.channelCreated = true;
   this.lastRelayURI = relayURI;
   this.lastTargetURI = targetURI;
   this.lastConfig = config;
   this.totalChannels++;

   return this._createMockChannel(
     targetURI,
     this.shouldSucceed,
     this.shouldUseContentTypeHeader
   );
 },

 /**
  * Creates a mock channel with configurable success behavior.
  *
  * @param {nsIURI} targetURI
  *   The URI for the channel.
  * @param {boolean} shouldSucceed
  *   Whether the channel should succeed.
  * @param {string} shouldUseContentTypeHeader
  *   The Content-Type to have a header value set to, or the empty string
  *   for no Content-Type.
  * @returns {nsIChannel}
  *   Mock channel implementation.
  */
 _createMockChannel(targetURI, shouldSucceed, shouldUseContentTypeHeader) {
   return {
     URI: targetURI,
     loadInfo: null,
     loadFlags: 0,
     notificationCallbacks: null,
     loadGroup: null,

     asyncOpen(listener) {
       Services.tm.dispatchToMainThread(() => {
         this._simulateChannelResponse(listener, shouldSucceed);
       });
     },

     _simulateChannelResponse(listener, success) {
       try {
         listener.onStartRequest(this);

         if (success) {
           const data = new ArrayBuffer(1024);
           const inputStream = Cc[
             "@mozilla.org/io/arraybuffer-input-stream;1"
           ].createInstance(Ci.nsIArrayBufferInputStream);
           inputStream.setData(data, 0, data.byteLength);
           listener.onDataAvailable(this, inputStream, 0, data.byteLength);
         }

         listener.onStopRequest(
           this,
           success ? Cr.NS_OK : Cr.NS_ERROR_FAILURE
         );
       } catch (e) {
         listener.onStopRequest(this, Cr.NS_ERROR_FAILURE);
       }
     },

     visitResponseHeaders(visitor) {
       if (shouldUseContentTypeHeader) {
         visitor.visitHeader("Content-Type", shouldUseContentTypeHeader);
       }
     },

     QueryInterface: ChromeUtils.generateQI(["nsIChannel", "nsIRequest"]),
   };
 },

 /**
  * Resets the mock service state to initial values.
  */
 reset() {
   this.channelCreated = false;
   this.totalChannels = 0;
   this.lastRelayURI = null;
   this.lastTargetURI = null;
   this.lastConfig = null;
   this.shouldSucceed = true;
   this.shouldUseContentTypeHeader = "";
 },

 QueryInterface: ChromeUtils.generateQI(["nsIObliviousHttpService"]),
};

add_setup(async () => {
 registerCleanupFunction(() => {
   // Invokes OnHandleClosed on any nsICacheEntry instances that have been
   // used, allowing them to be closed out before the nsICacheStorageService
   // shuts down (which causes leak assertion failures in debug builds).
   Cu.forceGC();
 });
});