| ARefBase.h |
|
833 |
| ArrayBufferInputStream.cpp |
|
3939 |
| ArrayBufferInputStream.h |
3014dde6-aa1c-41db-87d0-48764a3710f6 |
1298 |
| ascii_pac_utils.js |
global dnsResolve |
6026 |
| AutoClose.h |
|
1545 |
| BackgroundFileSaver.cpp |
Buffer size for writing to the output file or reading from the input file.
|
39973 |
| BackgroundFileSaver.h |
This file defines two implementations of the nsIBackgroundFileSaver
interface. See the "test_backgroundfilesaver.js" file for usage examples.
|
12725 |
| CacheInfoIPCTypes.h |
|
868 |
| CaptivePortalService.cpp |
|
13553 |
| CaptivePortalService.h |
|
2283 |
| ContentRange.cpp |
|
2362 |
| ContentRange.h |
|
1487 |
| Dashboard.cpp |
|
38095 |
| Dashboard.h |
Helper methods that pass the JSON to the callback function. |
2400 |
| DashboardTypes.h |
|
5333 |
| DefaultURI.cpp |
04445aa0-fd27-4c99-bd41-6be6318ae92c |
16801 |
| DefaultURI.h |
|
1567 |
| EventTokenBucket.cpp |
|
11135 |
| EventTokenBucket.h |
A token bucket is used to govern the maximum rate a series of events
can be executed at. For instance if your event was "eat a piece of cake"
then a token bucket configured to allow "1 piece per day" would spread
the eating of a 8 piece cake over 8 days even if you tried to eat the
whole thing up front. In a practical sense it 'costs' 1 token to execute
an event and tokens are 'earned' at a particular rate as time goes by.
The token bucket can be perfectly smooth or allow a configurable amount of
burstiness. A bursty token bucket allows you to save up unused credits, while
a perfectly smooth one would not. A smooth "1 per day" cake token bucket
would require 9 days to eat that cake if you skipped a slice on day 4
(use the token or lose it), while a token bucket configured with a burst
of 2 would just let you eat 2 slices on day 5 (the credits for day 4 and day
5) and finish the cake in the usual 8 days.
EventTokenBucket(hz=20, burst=5) creates a token bucket with the following
properties:
+ events from an infinite stream will be admitted 20 times per second (i.e.
hz=20 means 1 event per 50 ms). Timers will be used to space things evenly
down to 5ms gaps (i.e. up to 200hz). Token buckets with rates greater than
200hz will admit multiple events with 5ms gaps between them. 10000hz is the
maximum rate and 1hz is the minimum rate.
+ The burst size controls the limit of 'credits' that a token bucket can
accumulate when idle. For our (20,5) example each event requires 50ms of
credit (again, 20hz = 50ms per event). a burst size of 5 means that the
token bucket can accumulate a maximum of 250ms (5 * 50ms) for this bucket.
If no events have been admitted for the last full second the bucket can
still only accumulate 250ms of credit - but that credit means that 5 events
can be admitted without delay. A burst size of 1 is the minimum. The
EventTokenBucket is created with maximum credits already applied, but they
can be cleared with the ClearCredits() method. The maximum burst size is 15
minutes worth of events.
+ An event is submitted to the token bucket asynchronously through
SubmitEvent(). The OnTokenBucketAdmitted() method of the submitted event
is used as a callback when the event is ready to run. A cancelable event is
returned to the SubmitEvent() caller for use in the case they do not wish
to wait for the callback.
|
5864 |
| FuzzyLayer.cpp |
The flag `gFuzzingConnClosed` is set by `FuzzyClose` when all connections
are closed *and* there are no more buffers in `gNetworkFuzzingBuffers` that
must be used. The main thread spins until this becomes true to synchronize
the fuzzing iteration between the main thread and the socket thread, if
the prior call to `signalNetworkFuzzingDone` returned `false`.
|
13169 |
| FuzzyLayer.h |
|
842 |
| FuzzySecurityInfo.cpp |
|
3880 |
| FuzzySecurityInfo.h |
|
807 |
| FuzzySocketControl.cpp |
|
5136 |
| FuzzySocketControl.h |
|
777 |
| http-sfv |
|
|
| idna_glue |
|
|
| InterceptionInfo.cpp |
|
2045 |
| InterceptionInfo.h |
|
1361 |
| IPv4Parser.cpp |
|
9368 |
| IPv4Parser.h |
|
1183 |
| IPv6Utils.h |
|
1395 |
| LoadContextInfo.cpp |
|
5037 |
| LoadContextInfo.h |
|
1453 |
| LoadInfo.cpp |
static |
88635 |
| LoadInfo.h |
Class that provides an nsILoadInfo implementation.
|
18532 |
| LoadTainting.h |
|
1116 |
| makecppstring.py |
|
477 |
| MemoryDownloader.cpp |
-*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*- |
2330 |
| MemoryDownloader.h |
-*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*- |
1819 |
| moz.build |
|
8849 |
| mozIThirdPartyUtil.idl |
Utility functions for determining whether a given URI, channel, or window
hierarchy is third party with respect to a known URI.
|
8260 |
| mozurl |
|
|
| netCore.h |
|
490 |
| NetUtil.sys.mjs |
Necko utilities
|
14908 |
| NetworkConnectivityService.cpp |
|
18189 |
| NetworkConnectivityService.h |
|
2540 |
| NetworkDataCountLayer.cpp |
|
4548 |
| NetworkDataCountLayer.h |
|
834 |
| NetworkInfoServiceImpl.h |
|
567 |
| nsASocketHandler.h |
|
3058 |
| nsAsyncRedirectVerifyHelper.cpp |
|
9143 |
| nsAsyncRedirectVerifyHelper.h |
This class simplifies call of OnChannelRedirect of IOService and
the sink bound with the channel being redirected while the result of
redirect decision is returned through the callback.
|
3613 |
| nsAsyncStreamCopier.cpp |
An event used to perform initialization off the main thread.
|
11600 |
| nsAsyncStreamCopier.h |
|
2478 |
| nsAuthInformationHolder.cpp |
|
1414 |
| nsAuthInformationHolder.h |
This method can be used to initialize the username when the
ONLY_PASSWORD flag is set.
|
1214 |
| nsBase64Encoder.cpp |
|
1381 |
| nsBase64Encoder.h |
A base64 encoder. Usage: Instantiate class, write to it using
Write(), then call Finish() to get the base64-encoded data.
|
825 |
| nsBaseChannel.cpp |
|
27846 |
| nsBaseChannel.h |
|
12810 |
| nsBaseContentStream.cpp |
|
3765 |
| nsBaseContentStream.h |
|
3393 |
| nsBufferedStreams.cpp |
nothing |
33234 |
| nsBufferedStreams.h |
If there's a reference/pointer to an nsBufferedInputStream BEFORE calling
Init() AND the intent is to ultimately convert/assign that
reference/pointer to an nsIInputStream, DO NOT use that initial
reference/pointer. Instead, use the value of QueryInterface-ing to an
nsIInputStream (and, again, the QueryInterface must be performed after
Init()). This is because nsBufferedInputStream has multiple underlying
nsIInputStreams (one from nsIBufferedInputStream and one from
nsIAsyncInputStream), and the correct base nsIInputStream to use will be
unknown until the final value of mIsAsyncInputStream is set in Init().
This method, however, does just that but also hides the QI details and
will assert if called before Init().
|
5873 |
| nsDirectoryIndexStream.cpp |
The converts a filesystem directory into an "HTTP index" stream per
Lou Montulli's original spec:
http://www.mozilla.org/projects/netlib/dirindexformat.html
|
8843 |
| nsDirectoryIndexStream.h |
aDir will only be used on the calling thread.
|
1194 |
| nsDNSPrefetch.cpp |
|
5163 |
| nsDNSPrefetch.h |
|
2328 |
| nsDownloader.cpp |
|
2926 |
| nsDownloader.h |
|
954 |
| nsFileStreams.cpp |
|
28954 |
| nsFileStreams.h |
Flags describing our behavior. See the IDL file for possible values.
|
9348 |
| nsIArrayBufferInputStream.idl |
nsIArrayBufferInputStream
Provides scriptable methods for initializing a nsIInputStream
implementation with an ArrayBuffer.
|
1259 |
| nsIAsyncStreamCopier.idl |
Initialize the stream copier.
@param aSource
contains the data to be copied.
@param aSink
specifies the destination for the data.
@param aTarget
specifies the thread on which the copy will occur. a null value
is permitted and will cause the copy to occur on an unspecified
background thread.
@param aSourceBuffered
true if aSource implements ReadSegments.
@param aSinkBuffered
true if aSink implements WriteSegments.
@param aChunkSize
specifies how many bytes to read/write at a time. this controls
the granularity of the copying. it should match the segment size
of the "buffered" streams involved.
@param aCloseSource
true if aSource should be closed after copying.
@param aCloseSink
true if aSink should be closed after copying.
NOTE: at least one of the streams must be buffered. If you do not know
whether your streams are buffered, you should use nsIAsyncStreamCopier2
instead.
|
2424 |
| nsIAsyncStreamCopier2.idl |
Initialize the stream copier.
If neither the source nor the sink are buffered, buffering will
be automatically added to the sink.
@param aSource
contains the data to be copied.
@param aSink
specifies the destination for the data.
@param aTarget
specifies the thread on which the copy will occur. a null value
is permitted and will cause the copy to occur on an unspecified
background thread.
@param aChunkSize
specifies how many bytes to read/write at a time. this controls
the granularity of the copying. it should match the segment size
of the "buffered" streams involved.
@param aCloseSource
true if aSource should be closed after copying (this is generally
the desired behavior).
@param aCloseSink
true if aSink should be closed after copying (this is generally
the desired behavior).
|
2137 |
| nsIAsyncVerifyRedirectCallback.idl |
Complement to nsIChannelEventSink asynchronous callback. The result of
the redirect decision is passed through this callback.
@param result
Result of the redirect veto decision. If FAILED the redirect has been
vetoed. If SUCCEEDED the redirect has been allowed by all consumers.
|
749 |
| nsIAuthInformation.idl |
A object that hold authentication information. The caller of
nsIAuthPrompt2::promptUsernameAndPassword or
nsIAuthPrompt2::promptPasswordAsync provides an object implementing this
interface; the prompt implementation can then read the values here to prefill
the dialog. After the user entered the authentication information, it should
set the attributes of this object to indicate to the caller what was entered
by the user.
|
4036 |
| nsIAuthModule.idl |
Default behavior.
|
5610 |
| nsIAuthPrompt.idl |
Puts up a text input dialog with OK and Cancel buttons.
Note: prompt uses separate args for the "in" and "out" values of the
input field, whereas the other functions use a single inout arg.
@param dialogText The title for the dialog.
@param text The text to display in the dialog.
@param passwordRealm The "realm" the password belongs to: e.g.
ldap://localhost/dc=test
@param savePassword One of the SAVE_PASSWORD_* options above.
@param defaultText The default text to display in the text input box.
@param result The value entered by the user if OK was
selected.
@return true for OK, false for Cancel
|
6142 |
| nsIAuthPrompt2.idl |
An interface allowing to prompt for a username and password. This interface
is usually acquired using getInterface on notification callbacks or similar.
It can be used to prompt users for authentication information, either
synchronously or asynchronously.
|
4178 |
| nsIAuthPromptAdapterFactory.idl |
An interface for wrapping nsIAuthPrompt interfaces to make
them usable via an nsIAuthPrompt2 interface.
|
680 |
| nsIAuthPromptCallback.idl |
Interface for callback methods for the asynchronous nsIAuthPrompt2 method.
Callers MUST call exactly one method if nsIAuthPrompt2::promptPasswordAsync
returns successfully. They MUST NOT call any method on this interface before
promptPasswordAsync returns.
|
1524 |
| nsIAuthPromptProvider.idl |
Normal (non-proxy) prompt request.
|
1265 |
| nsIBackgroundFileSaver.idl |
Allows saving data to a file, while handling all the input/output on a
background thread, including the initial file name assignment and any
subsequent renaming of the target file.
This interface is designed for file downloads. Generally, they start in the
temporary directory, while the user is selecting the final name. Then, they
are moved to the chosen target directory with a ".part" extension appended to
the file name. Finally, they are renamed when the download is completed.
Components implementing both nsIBackgroundFileSaver and nsIStreamListener
allow data to be fed using an implementation of OnDataAvailable that never
blocks the calling thread. They suspend the request that drives the stream
listener in case too much data is being fed, and resume it when the data has
been written. Calling OnStopRequest does not necessarily close the target
file, and the Finish method must be called to complete the operation.
Components implementing both nsIBackgroundFileSaver and nsIAsyncOutputStream
allow data to be fed directly to the non-blocking output stream, that however
may return NS_BASE_STREAM_WOULD_BLOCK in case too much data is being fed.
Closing the output stream does not necessarily close the target file, and the
Finish method must be called to complete the operation.
@remarks Implementations may require the consumer to always call Finish. If
the object reference is released without calling Finish, a memory
leak may occur, and the target file might be kept locked. All
public methods of the interface may only be called from the main
thread.
|
7900 |
| nsIBaseChannel.idl |
The nsIBaseChannel interface allows C++ code to query the interface
of channels safely to gain access to content range functionality.
This allows subclasses to optionally handle range-requests on their
types using fetch/XMLHttpRequest even if they are not accessed via
HTTP and therefore normally do not have support for headers.
|
1968 |
| nsIBufferedStreams.idl |
An input stream that reads ahead and keeps a buffer coming from another input
stream so that fewer accesses to the underlying stream are necessary.
|
1555 |
| nsIByteRangeRequest.idl |
Returns true IFF this request is a byte range request, otherwise it
returns false (This is effectively the same as checking to see if
|startRequest| is zero and |endRange| is the content length.)
|
950 |
| nsICacheInfoChannel.idl |
Get the number of times the cache entry has been opened. This attribute is
equivalent to nsICachingChannel.cacheToken.fetchCount.
@throws NS_ERROR_NOT_AVAILABLE if the cache entry or the alternate data
cache entry cannot be read.
|
7636 |
| nsICachingChannel.idl |
A channel may optionally implement this interface to allow clients
to affect its behavior with respect to how it uses the cache service.
This interface provides:
1) Support for "stream as file" semantics (for JAR and plugins).
2) Support for "pinning" cached data in the cache (for printing and save-as).
3) Support for uniquely identifying cached data in cases when the URL
is insufficient (e.g., HTTP form submission).
|
4437 |
| nsICancelable.idl |
This interface provides a means to cancel an operation that is in progress.
|
863 |
| nsICaptivePortalService.idl |
Invoke callbacks after captive portal detection finished.
|
2649 |
| nsIChannel.idl |
The nsIChannel interface allows clients to construct "GET" requests for
specific protocols, and manage them in a uniform way. Once a channel is
created (via nsIIOService::newChannel), parameters for that request may
be set by using the channel attributes, or by QI'ing to a subclass of
nsIChannel for protocol-specific parameters. Then, the URI can be fetched
by calling nsIChannel::open or nsIChannel::asyncOpen.
After a request has been completed, the channel is still valid for accessing
protocol-specific results. For example, QI'ing to nsIHttpChannel allows
response headers to be retrieved for the corresponding http transaction.
This interface must be used only from the XPCOM main thread.
|
16456 |
| nsIChannelEventSink.idl |
Implement this interface to receive control over various channel events.
Channels will try to get this interface from a channel's
notificationCallbacks or, if not available there, from the loadGroup's
notificationCallbacks.
These methods are called before onStartRequest.
|
5115 |
| nsIChildChannel.idl |
Implemented by content side of IPC protocols.
|
1180 |
| nsIClassifiedChannel.idl |
nsIClassifiedChannel
A channel may optionally implement this interface if it carries classified
result information of channel classifier. The information contains, for
example, the name of matched table and the name of matched provider.
|
6539 |
| nsIClassOfService.idl |
nsIClassOfService.idl
Used to express class dependencies and characteristics - complimentary to
nsISupportsPriority which is used to express weight
Channels that implement this interface may make use of this
information in different ways.
|
5807 |
| nsIContentSniffer.idl |
Content sniffer interface. Components implementing this interface can
determine a MIME type from a chunk of bytes.
|
1296 |
| nsIDashboard.idl |
A JavaScript callback function that takes a JSON as its parameter.
The returned JSON contains arrays with data
|
2416 |
| nsIDashboardEventNotifier.idl |
These methods are called to register a websocket event with the dashboard
A host is identified by the (aHost, aSerial) pair.
aHost: the host's name: example.com
aSerial: a number that uniquely identifies the websocket
aEncrypted: if the connection is encrypted
aLength: the length of the message in bytes
|
1043 |
| nsIDHCPClient.idl |
This interface allows the proxy code to access the DHCP Options in a platform-specific way
|
640 |
| nsIDownloader.idl |
nsIDownloader
A downloader is a special implementation of a nsIStreamListener that will
make the contents of the stream available as a file. This may utilize the
disk cache as an optimization to avoid an extra copy of the data on disk.
The resulting file is valid from the time the downloader completes until
the last reference to the downloader is released.
|
1944 |
| nsIEncodedChannel.idl |
A channel interface which allows special handling of encoded content
|
2392 |
| nsIExternalProtocolHandler.idl |
This method checks if the external handler exists for a given scheme.
@param scheme external scheme.
@return TRUE if the external handler exists for the input scheme, FALSE otherwise.
|
648 |
| nsIFileStreams.idl |
An input stream that allows you to read from a file.
|
9130 |
| nsIFileURL.idl |
nsIFileURL provides access to the underlying nsIFile object corresponding to
an URL. The URL scheme need not be file:, since other local protocols may
map URLs to files (e.g., resource:).
|
1473 |
| nsIForcePendingChannel.idl |
nsIForcePending interface exposes a function that enables overwriting of the normal
behavior for the channel's IsPending(), forcing 'true' to be returned.
|
774 |
| nsIFormPOSTActionChannel.idl |
nsIFormPOSTActionChannel
Channel classes that want to be allowed for HTML form POST action must
implement this interface.
|
577 |
| nsIHttpAuthenticatorCallback.idl |
Authentication data for a header is available.
@param aCreds
Credentials which were obtained asynchonously.
@param aFlags
Flags set by asynchronous call.
@param aResult
Result status of credentials generation
@param aSessionState
Modified session state to be passed to caller
@param aContinuationState
Modified continuation state to be passed to caller
|
1051 |
| nsIHttpPushListener.idl |
nsIHttpPushListener
Used for triggering when a HTTP/2 push is received.
|
1255 |
| nsIIncrementalDownload.idl |
An incremental download object attempts to fetch a file piecemeal over time
in an effort to minimize network bandwidth usage.
Canceling a background download does not cause the file on disk to be
deleted.
|
4390 |
| nsIIncrementalStreamLoader.idl |
Same as nsIRequestObserver.onStartRequest.
Called when the loader observes onStartRequest.
@param aRequest request being observed
|
4356 |
| nsIInputStreamChannel.idl |
nsIInputStreamChannel
This interface provides methods to initialize an input stream channel.
The input stream channel serves as a data pump for an input stream.
|
2154 |
| nsIInputStreamPump.idl |
nsIInputStreamPump
This interface provides a means to configure and use a input stream pump
instance. The input stream pump will asynchronously read from an input
stream, and push data to an nsIStreamListener instance. It utilizes the
current thread's nsIEventTarget in order to make reading from the stream
asynchronous. A different thread can be used if the pump also implements
nsIThreadRetargetableRequest.
If the given stream supports nsIAsyncInputStream, then the stream pump will
call the stream's AsyncWait method to drive the stream listener. Otherwise,
the stream will be read on a background thread utilizing the stream
transport service. More details are provided below.
|
2807 |
| nsIInterceptionInfo.idl |
nsIInterceptionInfo is used to record the needed information of the
InterceptedHttpChannel.
This infomration need to be propagated to the new channel which created by
FetchEvent.request or ServiceWorker NavigationPreload.
|
2478 |
| nsIIOService.idl |
nsIIOService provides a set of network utility functions. This interface
duplicates many of the nsIProtocolHandler methods in a protocol handler
independent way (e.g., NewURI inspects the scheme in order to delegate
creation of the new URI to the appropriate protocol handler). nsIIOService
also provides a set of URL parsing utility functions. These are provided
as a convenience to the programmer and in some cases to improve performance
by eliminating intermediate data structures and interfaces.
|
15669 |
| nsILoadContextInfo.idl |
Helper interface to carry informatin about the load context
encapsulating origin attributes and IsAnonymous, IsPrivite properties.
It shall be used where nsILoadContext cannot be used or is not
available.
|
2642 |
| nsILoadGroup.idl |
A load group maintains a collection of nsIRequest objects.
This is used in lots of places where groups of requests need to be tracked.
For example, Document::mDocumentLoadGroup is used to track all requests
made for subdocuments in order to track page load progress and allow all
requests made on behalf of the document to be stopped, etc.
|
4320 |
| nsILoadGroupChild.idl |
nsILoadGroupChild provides a hierarchy of load groups so that the
root load group can be used to conceptually tie a series of loading
operations into a logical whole while still leaving them separate
for the purposes of cancellation and status events.
|
1547 |
| nsILoadInfo.idl |
The LoadInfo object contains information about a network load, why it
was started, and how we plan on using the resulting response.
If a network request is redirected, the new channel will receive a new
LoadInfo object. The new object will contain mostly the same
information as the pre-redirect one, but updated as appropriate.
For detailed information about what parts of LoadInfo are updated on
redirect, see documentation on individual properties.
|
63761 |
| nsIMIMEInputStream.idl |
The MIME stream separates headers and a datastream. It also allows
automatic creation of the content-length header.
|
1691 |
| nsIMultiPartChannel.idl |
An interface to access the the base channel
associated with a MultiPartChannel.
|
1566 |
| nsIncrementalDownload.cpp |
|
28161 |
| nsIncrementalStreamLoader.cpp |
readonly attribute nsIRequest request; |
6258 |
| nsIncrementalStreamLoader.h |
|
1764 |
| nsINestedURI.idl |
nsINestedURI is an interface that must be implemented by any nsIURI
implementation which has an "inner" URI that it actually gets data
from.
For example, if URIs for the scheme "sanitize" have the structure:
sanitize:http://example.com
and opening a channel on such a sanitize: URI gets the data from
http://example.com, sanitizes it, and returns it, then the sanitize: URI
should implement nsINestedURI and return the http://example.com URI as its
inner URI.
|
2671 |
| nsINetAddr.idl |
nsINetAddr
This interface represents a native NetAddr struct in a readonly
interface.
|
2545 |
| nsINetUtil.idl |
nsINetUtil provides various network-related utility methods.
|
8485 |
| nsINetworkConnectivityService.idl |
Each tested feature may be in one of 3 states:
UNKNOWN, if a check hasn't been performed.
OK, if the feature was successfully tested
NOT_AVAILABLE, if the feature is blocked by the network.
Note that the endpoints are guaranteed to support the features.
|
1738 |
| nsINetworkInfoService.idl |
Listener for getting list of addresses.
|
1806 |
| nsINetworkInterceptController.idl |
Interface allowing the nsIInterceptedChannel to callback when it is
done reading from the body stream.
|
8612 |
| nsINetworkLinkService.idl |
Network link status monitoring service.
|
4574 |
| nsINetworkPredictor.idl |
nsINetworkPredictor - learn about pages users visit, and allow us to take
predictive actions upon future visits.
NOTE: nsINetworkPredictor should only
be used on the main thread.
|
7076 |
| nsINetworkPredictorVerifier.idl |
nsINetworkPredictorVerifier - used for testing the network predictor to
ensure it does what we expect it to do.
|
1190 |
| nsInputStreamChannel.cpp |
|
2999 |
| nsInputStreamChannel.h |
|
1322 |
| nsInputStreamPump.cpp |
|
26504 |
| nsInputStreamPump.h |
Peek into the first chunk of data that's in the stream. Note that this
method will not call the callback when there is no data in the stream.
The callback will be called at most once.
The data from the stream will not be consumed, i.e. the pump's listener
can still read all the data
Do not call before asyncRead. Do not call after onStopRequest.
|
5218 |
| nsINullChannel.idl |
This interface is only used in order to mark the fact that
an object isn't a complete implementation of its interfaces.
For example, a consumer can QI NullHttpChannel to nsINullChannel,
to determine if the object is just a dummy implementation of nsIHttpChannel.
|
632 |
| nsIOService.cpp |
|
73560 |
| nsIOService.h |
|
11102 |
| nsIParentChannel.idl |
Implemented by chrome side of IPC protocols.
|
2351 |
| nsIParentRedirectingChannel.idl |
Asynchronous callback when redirected channel finishes the preparation for
completing the verification procedure.
@param result
SUCCEEDED if preparation for redirection verification succceed.
If FAILED the redirection must be aborted.
|
2468 |
| nsIPermission.idl |
This interface defines a "permission" object,
used to specify allowed/blocked objects from
user-specified sites (cookies, images etc).
|
2804 |
| nsIPermissionManager.idl |
This file contains an interface to the Permission Manager,
used to persistenly store permissions for different object types (cookies,
images etc) on a site-by-site basis.
This service broadcasts the following notification when the permission list
is changed:
topic : "perm-changed" (PERM_CHANGE_NOTIFICATION)
broadcast whenever the permission list changes in some way. there
are four possible data strings for this notification; one
notification will be broadcast for each change, and will involve
a single permission.
subject: an nsIPermission interface pointer representing the permission object
that changed.
data : "deleted"
a permission was deleted. the subject is the deleted permission.
"added"
a permission was added. the subject is the added permission.
"changed"
a permission was changed. the subject is the new permission.
"cleared"
the entire permission list was cleared. the subject is null.
|
12138 |
| nsIPrivateBrowsingChannel.idl |
This interface is implemented by channels which support overriding the
privacy state of the channel.
This interface must be used only from the XPCOM main thread.
|
2628 |
| nsIProgressEventSink.idl |
nsIProgressEventSink
This interface is used to asynchronously convey channel status and progress
information that is generally not critical to the processing of the channel.
The information is intended to be displayed to the user in some meaningful
way.
An implementation of this interface can be passed to a channel via the
channel's notificationCallbacks attribute. See nsIChannel for more info.
The channel will begin passing notifications to the progress event sink
after its asyncOpen method has been called. Notifications will cease once
the channel calls its listener's onStopRequest method or once the channel
is canceled (via nsIRequest::cancel).
NOTE: This interface is actually not specific to channels and may be used
with other implementations of nsIRequest.
|
2935 |
| nsIPrompt.idl |
This is the prompt interface which can be used without knowlege of a
parent window. The parentage is hidden by the GetInterface though
which it is gotten. This interface is identical to nsIPromptService
but without the parent nsIDOMWindow parameter. See nsIPromptService
for all documentation.
Accesskeys can be attached to buttons and checkboxes by inserting
an & before the accesskey character. For a real &, use && instead.
|
4619 |
| nsIProtocolHandler.idl |
Protocol handlers are registered with XPCOM under the following CONTRACTID prefix:
|
11514 |
| nsIProtocolProxyCallback.idl |
This interface serves as a closure for nsIProtocolProxyService's
asyncResolve method.
|
1630 |
| nsIProtocolProxyFilter.idl |
Recipient of the result of implementers of nsIProtocolProxy(Channel)Filter
allowing the proxyinfo be provided asynchronously.
|
4071 |
| nsIProtocolProxyService.idl |
Called when one of the following conditions are changed.
1. System proxy settings changed.
2. A proxy filter is registered or unregistered.
3. Proxy related prefs changed.
|
14261 |
| nsIProtocolProxyService2.idl |
An extension of nsIProtocolProxyService
|
1251 |
| nsIProxiedChannel.idl |
An interface for accessing the proxy info that a channel was
constructed with.
@see nsIProxiedProtocolHandler
|
1230 |
| nsIProxiedProtocolHandler.idl |
Create a new channel with the given proxyInfo
@param uri the channel uri
@param proxyInfo any proxy information that has already been determined,
or null if channel should later determine the proxy on its own using
proxyResolveFlags/proxyURI
@param proxyResolveFlags used if the proxy is later determined
from nsIProtocolProxyService::asyncResolve
@param proxyURI used if the proxy is later determined from
nsIProtocolProxyService::asyncResolve with this as the proxyURI name.
Generally this is the same as uri (or null which has the same
effect), except in the case of websockets which wants to bootstrap
to an http:// channel but make its proxy determination based on
a ws:// uri.
@param aLoadInfo used to evaluate who initated the resource request.
|
1721 |
| nsIProxyInfo.idl |
This interface identifies a proxy server.
|
3692 |
| nsIRandomGenerator.idl |
Interface used to generate random data.
@threadsafe
|
1318 |
| nsIRedirectChannelRegistrar.idl |
Used on the chrome process as a service to join channel implementation
and parent IPC protocol side under a unique id. Provides this way a generic
communication while redirecting to various protocols.
See also nsIChildChannel and nsIParentChannel.
|
2710 |
| nsIRedirectHistoryEntry.idl |
This nsIRedirectHistoryEntry defines an interface for specifying channel
redirect information
|
902 |
| nsIRedirectResultListener.idl |
When an HTTP redirect has been processed (either successfully or not)
nsIHttpChannel will call this function if its callbacks implement this
interface.
@param proceeding
Indicated whether the redirect will be proceeding, or not (i.e.
has been canceled, or failed).
|
803 |
| nsIRequest.idl |
nsIRequest
|
12441 |
| nsIRequestContext.idl |
Requests capable of tail-blocking must implement this
interfaces (typically channels).
If the request is tail-blocked, it will be held in its request
context queue until unblocked.
|
5126 |
| nsIRequestObserver.idl |
nsIRequestObserver
|
1478 |
| nsIRequestObserverProxy.idl |
A request observer proxy is used to ship data over to another thread
specified by the thread's dispatch target. The "true" request observer's
methods are invoked on the other thread.
This interface only provides the initialization needed after construction.
Otherwise, these objects are used simply as nsIRequestObserver's.
|
1326 |
| nsIResumableChannel.idl |
Prepare this channel for resuming. The request will not start until
asyncOpen or open is called. Calling resumeAt after open or asyncOpen
has been called has undefined behaviour.
@param startPos the starting offset, in bytes, to use to download
@param entityID information about the file, to match before obtaining
the file. Pass an empty string to use anything.
During OnStartRequest, this channel will have a status of
NS_ERROR_NOT_RESUMABLE if the file cannot be resumed, eg because the
server doesn't support this. This error may occur even if startPos
is 0, so that the front end can warn the user.
Similarly, the status of this channel during OnStartRequest may be
NS_ERROR_ENTITY_CHANGED, which indicates that the entity has changed,
as indicated by a changed entityID.
In both of these cases, no OnDataAvailable will be called, and
OnStopRequest will immediately follow with the same status code.
|
1782 |
| nsISecCheckWrapChannel.idl |
nsISecCheckWrapChannel
Describes an XPCOM component used to wrap channels for performing
security checks. Channels wrapped inside this class can use
this interface to query the wrapped inner channel.
|
698 |
| nsISecureBrowserUI.idl |
|
619 |
| nsISensitiveInfoHiddenURI.idl |
Returns the spec attribute with sensitive information hidden. This will
only affect uri with password. The password part of uri will be
transformed into "****".
|
659 |
| nsISerializationHelper.idl |
Simple scriptable serialization helper. Can be used as a service.
|
955 |
| nsIServerSocket.idl |
nsIServerSocket
An interface to a server socket that can accept incoming connections.
|
10592 |
| nsISimpleStreamListener.idl |
A simple stream listener can be used with AsyncRead to supply data to
a output stream.
|
829 |
| nsISimpleURIMutator.idl |
Same behaviour as nsIURISetSpec.setSpec() but filters whitespace.
|
536 |
| nsISocketFilter.idl |
Filters are created and run on the parent, and filter all packets, both
ingoing and outgoing. The child must specify the name of a recognized filter
in order to create a socket.
|
1855 |
| nsISocketTransport.idl |
nsISocketTransport
NOTE: Connection setup is triggered by opening an input or output stream,
it does not start on its own. Completion of the connection setup is
indicated by a STATUS_CONNECTED_TO notification to the event sink (if set).
NOTE: This is a free-threaded interface, meaning that the methods on
this interface may be called from any thread.
|
13433 |
| nsISocketTransportService.idl |
Observe will be called when the SocketTransportService is shutting down,
before threads are stopped.
|
6438 |
| nsISpeculativeConnect.idl |
Called as a hint to indicate a new transaction for the URI is likely coming
soon. The implementer may use this information to start a TCP
and/or SSL level handshake for that resource immediately so that it is
ready and/or progressed when the transaction is actually submitted.
No obligation is taken on by the implementer, nor is the submitter obligated
to actually open the new channel.
@param aURI the URI of the hinted transaction
@param aPrincipal the principal that will be used for opening the
channel of the hinted transaction.
@param aCallbacks any security callbacks for use with SSL for interfaces.
May be null.
@param aAnonymous indicates if this is an anonymous connection.
|
3334 |
| nsIStandardURL.idl |
nsIStandardURL defines the interface to an URL with the standard
file path format common to protocols like http, ftp, and file.
It supports initialization from a relative path and provides
some customization on how URLs are normalized.
|
3482 |
| nsIStreamListener.idl |
nsIStreamListener
|
1582 |
| nsIStreamListenerTee.idl |
As data "flows" into a stream listener tee, it is copied to the output stream
and then forwarded to the real listener.
|
1985 |
| nsIStreamLoader.idl |
Called when the entire stream has been loaded.
@param loader the stream loader that loaded the stream.
@param ctxt the context parameter of the underlying channel
@param status the status of the underlying channel
@param resultLength the length of the data loaded
@param result the data
This method will always be called asynchronously by the
nsIStreamLoader involved, on the thread that called the
loader's init() method.
If the observer wants to take over responsibility for the
data buffer (result), it returns NS_SUCCESS_ADOPTED_DATA
in place of NS_OK as its success code. The loader will then
"forget" about the data and not free() it after
onStreamComplete() returns; observer must call free()
when the data is no longer required.
|
2945 |
| nsIStreamTransportService.idl |
This service read/writes a stream on a background thread.
Note: instead of using this interface, probably you want to use
NS_MakeAsyncNonBlockingInputStream.
Use this service to transform any blocking stream (e.g., file stream)
into a fully asynchronous stream that can be read/written without
blocking the main thread.
|
1371 |
| nsISyncStreamListener.idl |
Returns an input stream that when read will fetch data delivered to the
sync stream listener. The nsIInputStream implementation will wait for
OnDataAvailable events before returning from Read.
NOTE: Reading from the returned nsIInputStream may spin the current
thread's event queue, which could result in any event being processed.
|
796 |
| nsISystemProxySettings.idl |
This interface allows the proxy code to use platform-specific proxy
settings when the proxy preference is set to "automatic discovery". This service
acts like a PAC parser to netwerk, but it will actually read the system settings and
either return the proper proxy data from the autoconfig URL specified in the system proxy,
or generate proxy data based on the system's manual proxy settings.
|
2062 |
| nsIThreadRetargetableRequest.idl |
nsIThreadRetargetableRequest
Should be implemented by requests that support retargeting delivery of
data off the main thread.
|
1650 |
| nsIThreadRetargetableStreamListener.idl |
nsIThreadRetargetableStreamListener
To be used by classes which implement nsIStreamListener and whose
OnDataAvailable callback may be retargeted for delivery off the main thread.
|
2169 |
| nsIThrottledInputChannel.idl |
An instance of this interface can be used to throttle the uploads
of a group of associated channels.
|
2893 |
| nsITimedChannel.idl |
|
5974 |
| nsITLSServerSocket.idl |
serverCert
The server's certificate that is presented to the client during the TLS
handshake. This is required to be set before calling |asyncListen|.
|
5745 |
| nsITraceableChannel.idl |
A channel implementing this interface allows one to intercept its data by
inserting intermediate stream listeners.
|
1651 |
| nsITransport.idl |
nsITransport
This interface provides a common way of accessing i/o streams connected
to some resource. This interface does not in any way specify the resource.
It provides methods to open blocking or non-blocking, buffered or unbuffered
streams to the resource. The name "transport" is meant to connote the
inherent data transfer implied by this interface (i.e., data is being
transfered in some fashion via the streams exposed by this interface).
A transport can have an event sink associated with it. The event sink
receives transport-specific events as the transfer is occuring. For a
socket transport, these events can include status about the connection.
See nsISocketTransport for more info about socket transport specifics.
|
6900 |
| nsIUDPSocket.idl |
nsIUDPSocket
An interface to a UDP socket that can accept incoming connections.
|
14605 |
| nsIUploadChannel.idl |
nsIUploadChannel
A channel may optionally implement this interface if it supports the
notion of uploading a data stream. The upload stream may only be set
prior to the invocation of asyncOpen on the channel.
|
2443 |
| nsIUploadChannel2.idl |
Sets a stream to be uploaded by this channel with the specified
Content-Type and Content-Length header values.
Most implementations of this interface require that the stream:
(1) implement threadsafe addRef and release
(2) implement nsIInputStream::readSegments
(3) implement nsISeekableStream::seek
@param aStream
The stream to be uploaded by this channel.
@param aContentType
This value will replace any existing Content-Type
header on the HTTP request, regardless of whether
or not its empty.
@param aContentLength
A value of -1 indicates that the length of the stream should be
determined by calling the stream's |available| method.
@param aMethod
The HTTP request method to set on the stream.
@param aStreamHasHeaders
True if the stream already contains headers for the HTTP request.
|
2344 |
| nsIURI.idl |
URIs are essentially structured names for things -- anything. This interface
provides accessors to get the most basic components of an URI.
If you need to change some parts of the URI use nsIURIMutator.
Subclasses, including nsIURL, impose greater structure on the URI.
This interface follows Tim Berners-Lee's URI spec (RFC3986) [1], where the
basic URI components are defined as such:
<pre>
ftp://username:password@hostname:portnumber/pathname?query#ref
\ / \ / \ / \ /\ / \ / \ /
- --------------- ------ -------- ------- --- -
| | | | | | |
| | | | FilePath Query Ref
| | | Port \ /
| | Host / ------------
| UserPass / |
Scheme / Path
\ /
--------------------------------
|
PrePath
</pre>
The definition of the URI components has been extended to allow for
internationalized domain names [2] and the more generic IRI structure [3].
[1] https://tools.ietf.org/html/rfc3986
[2] https://tools.ietf.org/html/rfc5890
[3] https://tools.ietf.org/html/rfc3987
|
10916 |
| nsIURIMutator.idl |
|
21277 |
| nsIURIMutatorUtils.cpp |
|
945 |
| nsIURIWithSpecialOrigin.idl |
nsIURIWithSpecialOrigin is implemented by URIs need to supply an origin that
does not match the spec. This is exclusively used in comm-central's Mailnews module.
|
630 |
| nsIURL.idl |
The nsIURL interface provides convenience methods that further
break down the path portion of nsIURI:
http://host/directory/fileBaseName.fileExtension?query
http://host/directory/fileBaseName.fileExtension#ref
\ \ /
\ -----------------------
\ | /
\ fileName /
----------------------------
|
filePath
|
5652 |
| nsIURLParser.idl |
nsIURLParser specifies the interface to an URL parser that attempts to
follow the definitions of RFC 2396.
|
4036 |
| nsLoadGroup.cpp |
|
35654 |
| nsLoadGroup.h |
Flags inherited from the default request in the load group onto other loads
added to the load group.
NOTE(emilio): If modifying these, be aware that we allow these flags to be
effectively set from the content process on a document navigation, and
thus nothing security-critical should be allowed here.
|
4031 |
| nsMediaFragmentURIParser.cpp |
|
9087 |
| nsMediaFragmentURIParser.h |
|
3799 |
| nsMIMEInputStream.cpp |
The MIME stream separates headers and a datastream. It also allows
automatic creation of the content-length header.
|
15617 |
| nsMIMEInputStream.h |
The MIME stream separates headers and a datastream. It also allows
automatic creation of the content-length header.
|
990 |
| nsNetAddr.cpp |
PR_NetAddrToString can handle INET and INET6, but not LOCAL. |
3240 |
| nsNetAddr.h |
additional members |
676 |
| nsNetSegmentUtils.h |
applies defaults to segment params in a consistent way.
|
678 |
| nsNetUtil.cpp |
= 0 |
137387 |
| nsNetUtil.h |
|
47834 |
| nsPACMan.cpp |
|
31756 |
| nsPACMan.h |
This class defines a callback interface used by AsyncGetProxyForURI.
|
9094 |
| nsPISocketTransportService.idl |
This is a private interface used by the internals of the networking library.
It will never be frozen. Do not use it in external code.
|
1442 |
| nsPreloadedStream.cpp |
|
3901 |
| nsPreloadedStream.h |
This class allows you to prefix an existing nsIAsyncInputStream
with a preloaded block of data known at construction time by wrapping the
two data sources into a new nsIAsyncInputStream. Readers of the new
stream initially see the preloaded data and when that has been exhausted
they automatically read from the wrapped stream.
It is used by nsHttpConnection when it has over buffered while reading from
the HTTP input socket and accidentally consumed data that belongs to
a different protocol via the HTTP Upgrade mechanism. That over-buffered
data is preloaded together with the input socket to form the new input socket
given to the new protocol handler.
|
1806 |
| nsProtocolProxyService.cpp |
|
80120 |
| nsProtocolProxyService.h |
This method is called whenever a preference may have changed or
to initialize all preferences.
@param prefs
This must be a pointer to the root pref branch.
@param name
This can be the name of a fully-qualified preference, or it can
be null, in which case all preferences will be initialized.
|
13734 |
| nsProxyInfo.cpp |
static |
6002 |
| nsProxyInfo.h |
ed42f751-825e-4cc2-abeb-3670711a8b85 |
3280 |
| nsReadLine.h |
@file
Functions to read complete lines from an input stream.
To properly use the helper function in here (NS_ReadLine) the caller should
create a nsLineBuffer<T> with new, and pass it to NS_ReadLine every time it
wants a line out.
When done, the object should be deleted.
|
4229 |
| nsRedirectHistoryEntry.cpp |
|
1303 |
| nsRedirectHistoryEntry.h |
|
939 |
| nsRequestObserverProxy.cpp |
|
6194 |
| nsRequestObserverProxy.h |
|
1439 |
| nsSerializationHelper.cpp |
|
1833 |
| nsSerializationHelper.h |
@file
Helper functions for (de)serializing objects to/from ASCII strings.
|
878 |
| nsServerSocket.cpp |
|
17319 |
| nsServerSocket.h |
|
2225 |
| nsSimpleNestedURI.cpp |
virtual |
6675 |
| nsSimpleNestedURI.h |
URI class to be used for cases when a simple URI actually resolves to some
other sort of URI, with the latter being what's loaded when the load
happens.
|
3354 |
| nsSimpleStreamListener.cpp |
|
2364 |
| nsSimpleStreamListener.h |
|
900 |
| nsSimpleURI.cpp |
static |
20865 |
| nsSimpleURI.h |
0b9bb0c2-fee6-470b-b9b9-9fd9462b5e19 |
5916 |
| nsSocketTransport2.cpp |
Following inclusions required for keepalive config not supported by NSPR. |
109517 |
| nsSocketTransport2.h |
|
16957 |
| nsSocketTransportService2.cpp |
|
60970 |
| nsSocketTransportService2.h |
|
13621 |
| nsStandardURL.cpp |
The UTS #46 ToUnicode operation as parametrized by the WHATWG URL Standard,
except potentially misleading labels are treated according to ToASCII
instead. Combined with the ToASCII operation without rerunning the expensive
part.
NOTE: This function performs percent-decoding on the argument unlike
the other `NS_DomainTo` functions!
If upon successfull return `aASCII` is empty, it is the caller's
responsibility to treat the value of `aDisplay` also as the value of
`aASCII`. (The weird semantics avoid useless allocation / copying.)
Rust callers that don't happen to be using XPCOM strings are better
off using the `idna` crate directly. (See `idna_glue` for what policy
closure to use.)
|
109397 |
| nsStandardURL.h |
|
20927 |
| nsStreamListenerTee.cpp |
|
5352 |
| nsStreamListenerTee.h |
|
1246 |
| nsStreamListenerWrapper.cpp |
|
1631 |
| nsStreamListenerWrapper.h |
|
2135 |
| nsStreamLoader.cpp |
|
4253 |
| nsStreamLoader.h |
|
1657 |
| nsStreamTransportService.cpp |
nsITransport * |
10853 |
| nsStreamTransportService.h |
|
1261 |
| nsSyncStreamListener.cpp |
|
5176 |
| nsSyncStreamListener.h |
|
1241 |
| nsTransportUtils.cpp |
|
4289 |
| nsTransportUtils.h |
This function returns a proxy object for a transport event sink instance.
The transport event sink will be called on the thread indicated by the
given event target. Like events are automatically coalesced. This means
that for example if the status value is the same from event to event, and
the previous event has not yet been delivered, then only one event will
be delivered. The progress reported will be that from the second event.
Coalescing events can help prevent a backlog of unprocessed transport
events in the case that the target thread is overworked.
|
1132 |
| nsUDPSocket.cpp |
|
44020 |
| nsUDPSocket.h |
|
3344 |
| nsURIHashKey.h |
Hashtable key class to use with nsTHashtable/nsBaseHashtable
|
1991 |
| nsURLHelper.cpp |
|
43554 |
| nsURLHelper.h |
retains /../ that reach above dir root (useful for FTP
servers in which the root of the FTP URL is not necessarily
the root of the FTP filesystem).
|
13419 |
| nsURLHelperOSX.cpp |
Mac OS X-specific local file uri parsing |
6761 |
| nsURLHelperUnix.cpp |
Unix-specific local file uri parsing |
2671 |
| nsURLHelperWin.cpp |
Windows-specific local file uri parsing |
3190 |
| nsURLParsers.cpp |
|
20037 |
| nsURLParsers.h |
|
4692 |
| PollableEvent.cpp |
|
11560 |
| PollableEvent.h |
|
2376 |
| Predictor.cpp |
|
81798 |
| Predictor.h |
|
18268 |
| PrivateBrowsingChannel.h |
|
3619 |
| ProtocolHandlerInfo.cpp |
|
2924 |
| ProtocolHandlerInfo.h |
|
2239 |
| ProxyAutoConfig.cpp |
|
29726 |
| ProxyAutoConfig.h |
Get the proxy string for the specified URI. The proxy string is
given by the following:
result = proxy-spec *( proxy-sep proxy-spec )
proxy-spec = direct-type | proxy-type LWS proxy-host [":" proxy-port]
direct-type = "DIRECT"
proxy-type = "PROXY" | "HTTP" | "HTTPS" | "SOCKS" | "SOCKS4" | "SOCKS5"
proxy-sep = ";" LWS
proxy-host = hostname | ipv4-address-literal
proxy-port = <any 16-bit unsigned integer>
LWS = *( SP | HT )
SP = <US-ASCII SP, space (32)>
HT = <US-ASCII HT, horizontal-tab (9)>
NOTE: direct-type and proxy-type are case insensitive
NOTE: SOCKS implies SOCKS4
Examples:
"PROXY proxy1.foo.com:8080; PROXY proxy2.foo.com:8080; DIRECT"
"SOCKS socksproxy"
"DIRECT"
XXX add support for IPv6 address literals.
XXX quote whatever the official standard is for PAC.
@param aTestURI
The URI as an ASCII string to test.
@param aTestHost
The ASCII hostname to test.
@param result
result string as defined above.
|
5360 |
| ProxyConfig.h |
|
5611 |
| RedirectChannelRegistrar.cpp |
|
2246 |
| RedirectChannelRegistrar.h |
|
1241 |
| RequestContextService.cpp |
|
16912 |
| RequestContextService.h |
|
1219 |
| rust-helper |
|
|
| ShutdownLayer.cpp |
|
2219 |
| ShutdownLayer.h |
SHUTDOWN_H___ |
669 |
| SimpleBuffer.cpp |
|
2255 |
| SimpleBuffer.h |
This class is similar to a nsPipe except it does not have any locking, stores
an unbounded amount of data, can only be used on one thread, and has much
simpler result code semantics to deal with.
|
1490 |
| SimpleChannel.cpp |
|
3812 |
| SimpleChannel.h |
Creates a simple channel which wraps an input stream created by the given
callbacks. The callbacks are not called until the underlying AsyncOpen or
Open methods are called, and correspond to the nsBaseChannel::StartAsyncRead
and nsBaseChannel::OpenContentStream methods of the same names.
The last two arguments of each callback are the created channel instance,
and the ref-counted context object passed to NS_NewSimpleChannel. A strong
reference to that object is guaranteed to be kept alive until after a
callback successfully completes.
|
5330 |
| SimpleChannelParent.cpp |
|
2768 |
| SimpleChannelParent.h |
NS_SIMPLECHANNELPARENT_H |
1248 |
| SimpleURIUnknownSchemes.cpp |
|
2434 |
| SimpleURIUnknownSchemes.h |
|
2009 |
| SimpleURIUnknownSchemesRemoteObserver.sys.mjs |
This method updates the io service with the local scheme list used to
bypass the defaultURI parser and use the simpleURI parser.
It also subscribes to Remote Settings changes to this list which are then
broadcast to processes interested in URL parsing.
note that there doesn't appear to be a way to get a URI with a non-special
scheme into about:preferences so it should be safe to spin this up early
|
3979 |
| SSLTokensCache.cpp |
|
17066 |
| SSLTokensCache.h |
|
4106 |
| ThrottleQueue.cpp |
|
10456 |
| ThrottleQueue.h |
An implementation of nsIInputChannelThrottleQueue that can be used
to throttle uploads. This class is not thread-safe.
Initialization and calls to WrapStream may be done on any thread;
but otherwise, after creation, it can only be used on the socket
thread. It currently throttles with a one second granularity, so
may be a bit choppy.
|
1888 |
| Tickler.cpp |
|
6229 |
| Tickler.h |
|
3829 |
| TLSServerSocket.cpp |
|
13513 |
| TLSServerSocket.h |
|
2633 |
| TRRLoadInfo.cpp |
|
23525 |
| TRRLoadInfo.h |
|
1816 |