tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

head_webtransport.js (3472B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 "use strict";
      6 
      7 /* import-globals-from head_cookies.js */
      8 
      9 let WebTransportListener = function () {};
     10 
     11 WebTransportListener.prototype = {
     12  onSessionReady(sessionId) {
     13    info("SessionId " + sessionId);
     14    this.ready();
     15  },
     16  onSessionClosed(errorCode, reason) {
     17    info("Error: " + errorCode + " reason: " + reason);
     18    if (this.closed) {
     19      this.closed();
     20    }
     21  },
     22  onIncomingBidirectionalStreamAvailable(stream) {
     23    info("got incoming bidirectional stream");
     24    this.streamAvailable(stream);
     25  },
     26  onIncomingUnidirectionalStreamAvailable(stream) {
     27    info("got incoming unidirectional stream");
     28    this.streamAvailable(stream);
     29  },
     30  onDatagramReceived(data) {
     31    info("got datagram");
     32    if (this.onDatagram) {
     33      this.onDatagram(data);
     34    }
     35  },
     36  onMaxDatagramSize(size) {
     37    info("max datagram size: " + size);
     38    if (this.onMaxDatagramSize) {
     39      this.onMaxDatagramSize(size);
     40    }
     41  },
     42  onOutgoingDatagramOutCome(id, outcome) {
     43    if (this.onDatagramOutcome) {
     44      this.onDatagramOutcome({ id, outcome });
     45    }
     46  },
     47 
     48  QueryInterface: ChromeUtils.generateQI(["WebTransportSessionEventListener"]),
     49 };
     50 
     51 function WebTransportStreamCallback() {}
     52 
     53 WebTransportStreamCallback.prototype = {
     54  QueryInterface: ChromeUtils.generateQI(["nsIWebTransportStreamCallback"]),
     55 
     56  onBidirectionalStreamReady(aStream) {
     57    Assert.notEqual(aStream, null);
     58    this.finish(aStream);
     59  },
     60  onUnidirectionalStreamReady(aStream) {
     61    Assert.notEqual(aStream, null);
     62    this.finish(aStream);
     63  },
     64  onError(aError) {
     65    this.finish(aError);
     66  },
     67 };
     68 
     69 function StreamStatsCallback() {}
     70 
     71 StreamStatsCallback.prototype = {
     72  QueryInterface: ChromeUtils.generateQI([
     73    "nsIWebTransportStreamStatsCallback",
     74  ]),
     75 
     76  onSendStatsAvailable(aStats) {
     77    Assert.notEqual(aStats, null);
     78    this.finish(aStats);
     79  },
     80  onReceiveStatsAvailable(aStats) {
     81    Assert.notEqual(aStats, null);
     82    this.finish(aStats);
     83  },
     84 };
     85 
     86 function inputStreamReader() {}
     87 
     88 inputStreamReader.prototype = {
     89  QueryInterface: ChromeUtils.generateQI(["nsIInputStreamCallback"]),
     90 
     91  onInputStreamReady(input) {
     92    let data = NetUtil.readInputStreamToString(input, input.available());
     93    this.finish(data);
     94  },
     95 };
     96 
     97 function streamCreatePromise(transport, bidi) {
     98  return new Promise(resolve => {
     99    let listener = new WebTransportStreamCallback().QueryInterface(
    100      Ci.nsIWebTransportStreamCallback
    101    );
    102    listener.finish = resolve;
    103 
    104    if (bidi) {
    105      transport.createOutgoingBidirectionalStream(listener);
    106    } else {
    107      transport.createOutgoingUnidirectionalStream(listener);
    108    }
    109  });
    110 }
    111 
    112 function sendStreamStatsPromise(stream) {
    113  return new Promise(resolve => {
    114    let listener = new StreamStatsCallback().QueryInterface(
    115      Ci.nsIWebTransportStreamStatsCallback
    116    );
    117    listener.finish = resolve;
    118 
    119    stream.QueryInterface(Ci.nsIWebTransportSendStream);
    120    stream.getSendStreamStats(listener);
    121  });
    122 }
    123 
    124 function receiveStreamStatsPromise(stream) {
    125  return new Promise(resolve => {
    126    let listener = new StreamStatsCallback().QueryInterface(
    127      Ci.nsIWebTransportStreamStatsCallback
    128    );
    129    listener.finish = resolve;
    130 
    131    stream.QueryInterface(Ci.nsIWebTransportReceiveStream);
    132    stream.getReceiveStreamStats(listener);
    133  });
    134 }