| AltDataOutputStreamChild.cpp |
stabilize |
5079 |
| AltDataOutputStreamChild.h |
|
1715 |
| AltDataOutputStreamParent.cpp |
|
2337 |
| AltDataOutputStreamParent.h |
|
1889 |
| AlternateServices.cpp |
RFC 7838 Alternative Services
http://httpwg.org/http-extensions/opsec.html
note that connections currently do not do mixed-scheme (the I attribute
in the ConnectionInfo prevents it) but could, do not honor tls-commit and
should not, and always require authentication
|
44588 |
| AlternateServices.h |
Alt-Svc allows separation of transport routing from the origin host without
using a proxy. See https://httpwg.github.io/http-extensions/alt-svc.html and
https://tools.ietf.org/html/draft-ietf-httpbis-alt-svc-06
Nice To Have Future Enhancements::
flush on network change event when we have an indicator
use established https channel for http instead separate of conninfo hash
pin via http-tls header
clear based on origin when a random fail happens not just 421
upon establishment of channel, cancel and retry trans that have not yet
written anything
persistent storage (including private browsing filter)
memory reporter for cache, but this is rather tiny
|
9206 |
| AltServiceChild.cpp |
|
3040 |
| AltServiceChild.h |
|
1336 |
| AltServiceParent.cpp |
|
1922 |
| AltServiceParent.h |
|
1280 |
| AltSvcTransactionChild.cpp |
|
2411 |
| AltSvcTransactionChild.h |
|
1137 |
| AltSvcTransactionParent.cpp |
|
2243 |
| AltSvcTransactionParent.h |
|
1814 |
| ASpdySession.cpp |
Currently supported is h2
|
3139 |
| ASpdySession.h |
|
4089 |
| BackgroundChannelRegistrar.cpp |
|
2892 |
| BackgroundChannelRegistrar.h |
|
1909 |
| BackgroundDataBridgeChild.cpp |
|
1736 |
| BackgroundDataBridgeChild.h |
|
1390 |
| BackgroundDataBridgeParent.cpp |
|
2267 |
| BackgroundDataBridgeParent.h |
|
1182 |
| CacheControlParser.cpp |
|
3452 |
| CacheControlParser.h |
|
1338 |
| CachePushChecker.cpp |
|
8311 |
| CachePushChecker.h |
|
1324 |
| ClassifierDummyChannel.cpp |
static |
21588 |
| ClassifierDummyChannel.h |
In child intercept mode, the decision to intercept a channel is made in the
child process without consulting the parent process. The decision is based
on whether there is a ServiceWorker with a scope covering the URL in question
and whether storage is allowed for the origin/URL. When the
"network.cookie.cookieBehavior" preference is set to BEHAVIOR_REJECT_TRACKER,
annotated channels are denied storage which means that the ServiceWorker
should not intercept the channel. However, the decision for tracking
protection to annotate a channel only occurs in the parent process. The
dummy channel is a hack to allow the intercept decision process to ask the
parent process if the channel should be annotated. Because this round-trip
to the parent has overhead, the dummy channel is only created 1) if the
ServiceWorker initially determines that the channel should be intercepted and
2) it's a navigation request.
This hack can be removed once Bug 1231208's new "parent intercept" mechanism
fully lands, the pref is enabled by default it stays enabled for long enough
to be confident we will never need/want to turn it off. Then as part of bug
1496997 we can remove this implementation. Bug 1498259 covers removing this
hack in particular.
|
3461 |
| ClassifierDummyChannelChild.cpp |
static |
2759 |
| ClassifierDummyChannelChild.h |
|
1449 |
| ClassifierDummyChannelParent.cpp |
|
1602 |
| ClassifierDummyChannelParent.h |
|
1143 |
| ClassOfService.h |
|
1960 |
| components.conf |
|
583 |
| ConnectionDiagnostics.cpp |
|
9307 |
| ConnectionEntry.cpp |
|
31823 |
| ConnectionEntry.h |
|
7855 |
| ConnectionHandle.cpp |
|
2695 |
| ConnectionHandle.h |
|
1281 |
| DnsAndConnectSocket.cpp |
|
47965 |
| DnsAndConnectSocket.h |
State:
INIT: initial state. From this state:
1) change the state to RESOLVING and start the primary DNS lookup
if mSkipDnsResolution is false,
2) or the lookup is skip and the state changes to CONNECTING and
start the backup timer.
3) or changes to DONE in case of an error.
RESOLVING: the primary DNS resolution is in progress. From this state
we transition into CONNECTING or DONE.
CONNECTING: We change to this state when the primary connection has
started. At that point the backup timer is started.
ONE_CONNECTED: We change into this state when one of the connections
is connected and the second is in progres.
DONE
Events:
INIT_EVENT: Start the primary dns resolution (if mSkipDnsResolution is
false), otherwise start the primary connection.
RESOLVED_PRIMARY_EVENT: the primary DNS resolution is done. This event
may be resent due to DNS retries
CONNECTED_EVENT: A connecion (primary or backup) is done
|
9421 |
| EarlyHintPreloader.cpp |
static |
14431 |
| EarlyHintPreloader.h |
|
3596 |
| EarlyHintsService.cpp |
|
5131 |
| EarlyHintsService.h |
|
1143 |
| http2_huffman_table.txt |
|
17733 |
| Http2Compression.cpp |
|
45614 |
| Http2Compression.h |
|
6340 |
| Http2ConnectTransaction.cpp |
|
38479 |
| Http2ConnectTransaction.h |
The input path of http over a spdy CONNECT tunnel once it is established as a
stream
note the "real http transaction" can be either a http/1 transaction or another
spdy session inside the tunnel.
nsHttpConnection::OnInputStreamReady (real socket)
nsHttpConnection::OnSocketReadable()
SpdySession::WriteSegment()
SpdyStream::WriteSegment (tunnel stream)
Http2ConnectTransaction::WriteSegment
SpdyStream::OnWriteSegment(tunnel stream)
SpdySession::OnWriteSegment()
SpdySession::NetworkRead()
nsHttpConnection::OnWriteSegment (real socket)
realSocketIn->Read() return data from network
now pop the stack back up to Http2ConnectTransaction::WriteSegment, the data
that has been read is stored mInputData
Http2ConnectTransaction.mTunneledConn::OnInputStreamReady(mTunnelStreamIn)
Http2ConnectTransaction.mTunneledConn::OnSocketReadable()
TLSFilterTransaction::WriteSegment()
nsHttpTransaction::WriteSegment(real http transaction)
TLSFilterTransaction::OnWriteSegment() removes tls on way back up stack
Http2ConnectTransaction.mTunneledConn::OnWriteSegment()
// gets data from mInputData
Http2ConnectTransaction.mTunneledConn.mTunnelStreamIn->Read()
The output path works similarly:
nsHttpConnection::OnOutputStreamReady (real socket)
nsHttpConnection::OnSocketWritable()
SpdySession::ReadSegments (locates tunnel)
SpdyStream::ReadSegments (tunnel stream)
Http2ConnectTransaction::ReadSegments()
Http2ConnectTransaction.mTunneledConn::OnOutputStreamReady (tunnel connection)
Http2ConnectTransaction.mTunneledConn::OnSocketWritable (tunnel connection)
TLSFilterTransaction::ReadSegment()
nsHttpTransaction::ReadSegment (real http transaction generates plaintext on
way down)
TLSFilterTransaction::OnReadSegment (BUF and LEN gets encrypted here on way
down)
Http2ConnectTransaction.mTunneledConn::OnReadSegment (BUF and LEN)
(tunnel connection)
Http2ConnectTransaction.mTunneledConn.mTunnelStreamOut->Write(BUF, LEN) ..
get stored in mOutputData
Now pop the stack back up to Http2ConnectTransaction::ReadSegment(), where it
has the encrypted text available in mOutputData
SpdyStream->OnReadSegment(BUF,LEN) from mOutputData. Tunnel stream
SpdySession->OnReadSegment() // encrypted data gets put in a data frame
nsHttpConnection->OnReadSegment()
realSocketOut->write() writes data to network
************************************************************************ |
7630 |
| Http2HuffmanIncoming.h |
THIS FILE IS AUTO-GENERATED. DO NOT EDIT!
|
45375 |
| Http2HuffmanOutgoing.h |
THIS FILE IS AUTO-GENERATED. DO NOT EDIT!
|
5272 |
| Http2Push.cpp |
|
18216 |
| Http2Push.h |
|
6134 |
| Http2Session.cpp |
|
162276 |
| Http2Session.h |
HTTP/2 framing
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Length (16) | Type (8) | Flags (8) |
+-+-------------+---------------+-------------------------------+
|R| Stream Identifier (31) |
+-+-------------------------------------------------------------+
| Frame Data (0...) ...
+---------------------------------------------------------------+
|
24884 |
| Http2Stream.cpp |
|
10147 |
| Http2Stream.h |
|
2027 |
| Http2StreamBase.cpp |
|
45730 |
| Http2StreamBase.h |
|
12050 |
| Http2StreamTunnel.cpp |
|
19527 |
| Http2StreamTunnel.h |
|
4415 |
| Http2StreamWebSocket.cpp |
|
3863 |
| Http2StreamWebSocket.h |
|
1824 |
| Http3Session.cpp |
|
66054 |
| Http3Session.h |
|
7893 |
| Http3Stream.cpp |
|
16681 |
| Http3Stream.h |
SendStreamState:
While sending request:
- PREPARING_HEADERS:
In this state we are collecting the headers and in some cases also
waiting to be able to create a new stream.
We need to read all headers into a buffer before calling
Http3Session::TryActivating. Neqo may not have place for a new
stream if it hits MAX_STREAMS limit. In that case the steam will be
queued and dequeue when neqo can again create new stream
(RequestsCreatable will be called).
If transaction has data to send state changes to SENDING_BODY,
otherwise the state transfers to READING_HEADERS.
- SENDING_BODY:
The stream will be in this state while the transaction is sending
request body. Http3Session::SendRequestBody will be call to give
the data to neqo.
After SENDING_BODY, the state transfers to READING_HEADERS.
- EARLY_RESPONSE:
The server may send STOP_SENDING frame with error HTTP_NO_ERROR.
That error means that the server is not interested in the request
body. In this state the server will just ignore the request body.
|
6029 |
| HttpAuthUtils.cpp |
host: bar.com foo.bar.com foobar.com foo.bar.com bar.com
pref: bar.com bar.com bar.com .bar.com .bar.com
result: accept accept reject accept reject
|
4742 |
| HttpAuthUtils.h |
Tries to match the given URI against the value of a given pref
The pref should be in pseudo-BNF format.
url-list base-url ( base-url "," LWS )*
base-url ( scheme-part | host-part | scheme-part host-part )
scheme-part scheme "://"
host-part host [":" port]
for example:
"https://, http://office.foo.com"
Will return true if the URI matches any of the patterns, or false otherwise.
|
925 |
| HttpBackgroundChannelChild.cpp |
|
16239 |
| HttpBackgroundChannelChild.h |
|
5594 |
| HttpBackgroundChannelParent.cpp |
Helper class for continuing the AsyncOpen procedure on main thread.
|
16116 |
| HttpBackgroundChannelParent.h |
|
4492 |
| HttpBaseChannel.cpp |
|
188687 |
| HttpBaseChannel.h |
This class is a partial implementation of nsIHttpChannel. It contains code
shared by nsHttpChannel and HttpChannelChild.
- Note that this class has nothing to do with nsBaseChannel, which is an
earlier effort at a base class for channels that somehow never made it all
the way to the HTTP channel.
|
41574 |
| HttpChannelChild.cpp |
|
103150 |
| HttpChannelChild.h |
|
18536 |
| HttpChannelParams.ipdlh |
|
1769 |
| HttpChannelParent.cpp |
|
69495 |
| HttpChannelParent.h |
|
12856 |
| HttpConnectionBase.cpp |
|
2156 |
| HttpConnectionBase.h |
|
8603 |
| HttpConnectionMgrChild.cpp |
|
6498 |
| HttpConnectionMgrChild.h |
|
2223 |
| HttpConnectionMgrParent.cpp |
|
10484 |
| HttpConnectionMgrParent.h |
|
1472 |
| HttpConnectionMgrShell.h |
|
11262 |
| HttpConnectionUDP.cpp |
|
21332 |
| HttpConnectionUDP.h |
|
3998 |
| HttpInfo.cpp |
|
522 |
| HttpInfo.h |
Calls getConnectionData method in nsHttpConnectionMgr. |
569 |
| HttpLog.h |
This file should ONLY be #included by source (.cpp) files in the /http
directory, not headers (.h). If you need to use LOG() in a .h file, call
PR_LOG directly.
This file should also be the first #include in your file.
Yes, this is kludgy.
***************************************************************************** |
2584 |
| HTTPSRecordResolver.cpp |
|
3976 |
| HTTPSRecordResolver.h |
|
1260 |
| HttpTrafficAnalyzer.cpp |
|
11452 |
| HttpTrafficAnalyzer.h |
|
1598 |
| HttpTrafficAnalyzer.inc |
|
4817 |
| HttpTransactionChild.cpp |
|
22691 |
| HttpTransactionChild.h |
|
5191 |
| HttpTransactionParent.cpp |
stabilize |
29272 |
| HttpTransactionParent.h |
|
6862 |
| HttpTransactionShell.h |
|
10936 |
| HttpWinUtils.cpp |
merge |
3507 |
| HttpWinUtils.h |
|
434 |
| InterceptedHttpChannel.cpp |
|
47972 |
| InterceptedHttpChannel.h |
InterceptionTimeStamps is used to record the time stamps of the
interception.
The general usage:
Step 1. Initialize the InterceptionTimeStamps;
InterceptionTimeStamps::Init(channel);
Step 2. Record time for each stage
InterceptionTimeStamps::RecordTime(); or
InterceptionTimeStamps::RecordTime(timeStamp);
Step 3. Record time for the last stage with the final status
InterceptionTimeStamps::RecordTime(InterceptionTimeStamps::Synthesized);
|
9862 |
| make_incoming_tables.py |
|
5798 |
| make_outgoing_tables.py |
/*
* THIS FILE IS AUTO-GENERATED. DO NOT EDIT!
*/
#ifndef mozilla__net__Http2HuffmanOutgoing_h
#define mozilla__net__Http2HuffmanOutgoing_h
namespace mozilla {
namespace net {
struct HuffmanOutgoingEntry {
uint32_t mValue;
uint8_t mLength;
};
static const HuffmanOutgoingEntry HuffmanOutgoing[] = {
|
1473 |
| metrics.yaml |
|
960 |
| moz.build |
|
5963 |
| NetworkMarker.cpp |
|
7279 |
| NetworkMarker.h |
|
1321 |
| nsAHttpConnection.h |
|
14203 |
| nsAHttpTransaction.h |
Xlib headers insist on this for some reason... Nuke it because
it'll override our member name |
13087 |
| nsCORSListenerProxy.cpp |
|
58434 |
| nsCORSListenerProxy.h |
|
4986 |
| nsHttp.cpp |
|
33805 |
| nsHttp.h |
|
15514 |
| nsHttpActivityDistributor.cpp |
|
9854 |
| nsHttpActivityDistributor.h |
|
1171 |
| nsHttpAtomList.h |
This file contains the list of all HTTP atoms
See nsHttp.h for access to the atoms.
It is designed to be used as inline input to nsHttp.cpp *only*
through the magic of C preprocessing.
All entries must be enclosed in the macro HTTP_ATOM which will have cruel
and unusual things done to it.
The first argument to HTTP_ATOM is the C++ name of the atom.
The second argument to HTTP_ATOM is the string value of the atom.
**** |
4037 |
| nsHttpAuthCache.cpp |
|
11806 |
| nsHttpAuthCache.h |
|
7740 |
| nsHttpAuthManager.cpp |
|
3538 |
| nsHttpAuthManager.h |
|
845 |
| nsHttpBasicAuth.cpp |
|
3568 |
| nsHttpBasicAuth.h |
|
1150 |
| nsHttpChannel.cpp |
|
337242 |
| nsHttpChannel.h |
|
35596 |
| nsHttpChannelAuthProvider.cpp |
|
65801 |
| nsHttpChannelAuthProvider.h |
Following three methods return NS_ERROR_IN_PROGRESS when
nsIAuthPrompt2.asyncPromptAuth method is called. This result indicates
the user's decision will be gathered in a callback and is not an actual
error.
|
7391 |
| nsHttpChunkedDecoder.cpp |
|
5267 |
| nsHttpChunkedDecoder.h |
|
1570 |
| nsHttpConnection.cpp |
|
83590 |
| nsHttpConnection.h |
|
14075 |
| nsHttpConnectionInfo.cpp |
|
19981 |
| nsHttpConnectionInfo.h |
|
11353 |
| nsHttpConnectionMgr.cpp |
|
126709 |
| nsHttpConnectionMgr.h |
|
20124 |
| nsHttpDigestAuth.cpp |
|
23413 |
| nsHttpDigestAuth.h |
|
3323 |
| nsHttpHandler.cpp |
;q=0.1"
#define ACCEPT_HEADER_ALL " |
95739 |
| nsHttpHandler.h |
FRAMECHECK_LAX - no check
FRAMECHECK_BARELY - allows:
1) that chunk-encoding does not have the last 0-size
chunk. So, if a chunked-encoded transfer ends on exactly
a chunk boundary we consider that fine. This will allows
us to accept buggy servers that do not send the last
chunk. It will make us not detect a certain amount of
cut-offs.
2) When receiving a gzipped response, we consider a
gzip stream that doesn't end fine according to the gzip
decompressing state machine to be a partial transfer.
If a gzipped transfer ends fine according to the
decompressor, we do not check for size unalignments.
This allows to allow HTTP gzipped responses where the
Content-Length is not the same as the actual contents.
3) When receiving HTTP that isn't
content-encoded/compressed (like in case 2) and not
chunked (like in case 1), perform the size comparison
between Content-Length: and the actual size received
and consider a mismatch to mean a
NS_ERROR_NET_PARTIAL_TRANSFER error.
FRAMECHECK_STRICT_CHUNKED - This is the same as FRAMECHECK_BARELY only we
enforce that the last 0-size chunk is received
in case 1).
FRAMECHECK_STRICT - we also do not allow case 2) and 3) from
FRAMECHECK_BARELY.
|
34043 |
| nsHttpHeaderArray.cpp |
|
15055 |
| nsHttpHeaderArray.h |
|
11344 |
| nsHttpNTLMAuth.cpp |
|
14152 |
| nsHttpNTLMAuth.h |
|
883 |
| nsHttpRequestHead.cpp |
= nsHttpHeaderArray::eFilterAll |
10558 |
| nsHttpRequestHead.h |
|
5649 |
| nsHttpResponseHead.cpp |
|
39409 |
| nsHttpResponseHead.h |
Xlib headers insist on this for some reason... Nuke it because
it'll override our member name |
9550 |
| nsHttpTransaction.cpp |
|
117276 |
| nsHttpTransaction.h |
|
21933 |
| nsIBackgroundChannelRegistrar.idl |
Registrar for pairing HttpChannelParent and HttpBackgroundChannelParent via
channel Id. HttpChannelParent::OnBackgroundParentReady and
HttpBackgroundChannelParent::LinkToChannel will be invoked to notify the
existence of associated channel object.
|
2438 |
| nsICorsPreflightCallback.h |
|
1094 |
| nsIEarlyHintObserver.idl |
This method is called when the transaction has early hint (i.e. the
'103 Early Hint' informational response) headers.
|
603 |
| nsIHttpActivityObserver.idl |
nsIHttpActivityObserver
This interface provides a way for http activities to be reported
to observers.
|
9351 |
| nsIHttpAuthenticableChannel.idl |
If the channel being authenticated is using SSL.
|
3869 |
| nsIHttpAuthenticator.idl |
nsIHttpAuthenticator
Interface designed to allow for pluggable HTTP authentication modules.
Implementations are registered under the ContractID:
"@mozilla.org/network/http-authenticator;1?scheme=<auth-scheme>"
where <auth-scheme> is the lower-cased value of the authentication scheme
found in the server challenge per the rules of RFC 2617.
|
10074 |
| nsIHttpAuthManager.idl |
nsIHttpAuthManager
This service provides access to cached HTTP authentication
user credentials (domain, username, password) for sites
visited during the current browser session.
This interface exists to provide other HTTP stacks with the
ability to share HTTP authentication credentials with Necko.
This is currently used by the Java plugin (version 1.5 and
higher) to avoid duplicate authentication prompts when the
Java client fetches content from a HTTP site that the user
has already logged into.
|
4889 |
| nsIHttpChannel.idl |
nsIHttpChannel
This interface allows for the modification of HTTP request parameters and
the inspection of the resulting HTTP response status and headers when they
become available.
|
19312 |
| nsIHttpChannelAuthProvider.idl |
nsIHttpChannelAuthProvider
This interface is intended for providing authentication for http-style
channels, like nsIHttpChannel and nsIWebSocket, which implement the
nsIHttpAuthenticableChannel interface.
When requesting pages AddAuthorizationHeaders MUST be called
in order to get the http cached headers credentials. When the request is
unsuccessful because of receiving either a 401 or 407 http response code
ProcessAuthentication MUST be called and the page MUST be requested again
with the new credentials that the user has provided. After a successful
request, checkForSuperfluousAuth MAY be called, and disconnect MUST be
called.
|
3237 |
| nsIHttpChannelChild.idl |
|
1455 |
| nsIHttpChannelInternal.idl |
The callback interface for nsIHttpChannelInternal::HTTPUpgrade()
|
16891 |
| nsIHttpHeaderVisitor.idl |
Implement this interface to visit http headers.
|
898 |
| nsIHttpProtocolHandler.idl |
Get the HTTP advertised user agent string.
|
7067 |
| nsIRaceCacheWithNetwork.idl |
This holds methods used to race the cache with the network for a specific
channel. This interface is was designed with nsHttpChannel in mind, and it's
expected this will be the only class implementing it.
|
2329 |
| nsITlsHandshakeListener.idl |
|
471 |
| nsIWellKnownOpportunisticUtils.idl |
For parsing JSON from http://httpwg.org/http-extensions/opsec.html
|
754 |
| nsServerTiming.cpp |
|
3608 |
| nsServerTiming.h |
|
1326 |
| NullHttpChannel.cpp |
|
21654 |
| NullHttpChannel.h |
|
1835 |
| NullHttpTransaction.cpp |
|
7055 |
| NullHttpTransaction.h |
|
3051 |
| OpaqueResponseUtils.cpp |
|
6686 |
| OpaqueResponseUtils.h |
|
1217 |
| PAltDataOutputStream.ipdl |
|
1268 |
| PAltService.ipdl |
|
1147 |
| PAltSvcTransaction.ipdl |
|
604 |
| ParentChannelListener.cpp |
|
9675 |
| ParentChannelListener.h |
|
3179 |
| PBackgroundDataBridge.ipdl |
|
891 |
| PClassifierDummyChannel.ipdl |
|
2123 |
| PendingTransactionInfo.cpp |
|
4669 |
| PendingTransactionInfo.h |
|
2108 |
| PendingTransactionQueue.cpp |
= false |
9725 |
| PendingTransactionQueue.h |
|
3164 |
| PHttpBackgroundChannel.ipdl |
|
2673 |
| PHttpChannel.ipdl |
|
5036 |
| PHttpChannelParams.h |
|
9590 |
| PHttpConnectionMgr.ipdl |
|
1804 |
| PHttpTransaction.ipdl |
|
3967 |
| PSpdyPush.h |
A pushed stream is put into a memory buffer (The SpdyPushTransactionBuffer)
and spooled there until a GET is made that can be matched up with it. At
that time we have two spdy streams - the GET (aka the sink) and the PUSH
(aka the source). Data is copied between those two streams for the lifetime
of the transaction. This is true even if the transaction buffer is empty,
partly complete, or totally loaded at the time the GET correspondence is made.
correspondence is done through a hash table of the full url, the spdy session,
and the load group. The load group is implicit because that's where the
hash is stored, the other items comprise the hash key.
Pushed streams are subject to aggressive flow control before they are matched
with a GET at which point flow control is effectively disabled to match the
client pull behavior.
|
2083 |
| QuicSocketControl.cpp |
|
4888 |
| QuicSocketControl.h |
|
2150 |
| README |
Darin Fisher |
4209 |
| SpeculativeTransaction.cpp |
|
3246 |
| SpeculativeTransaction.h |
|
2322 |
| TimingStruct.h |
|
1168 |
| TlsHandshaker.cpp |
|
10422 |
| TlsHandshaker.h |
|
3135 |
| TLSTransportLayer.cpp |
|
25289 |
| TLSTransportLayer.h |
|
6327 |
| TRRServiceChannel.cpp |
|
48521 |
| TRRServiceChannel.h |
|
6522 |
| WellKnownOpportunisticUtils.jsm |
-*- indent-tabs-mode: nil; js-indent-level: 2 -*- |
820 |