Name Description Size
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 37762
Dashboard.h Helper methods that pass the JSON to the callback function. 2400
DashboardTypes.h 5109
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`. 13111
FuzzyLayer.h 842
FuzzySecurityInfo.cpp 3880
FuzzySecurityInfo.h 807
FuzzySocketControl.cpp 5136
FuzzySocketControl.h 777
InterceptionInfo.cpp 2045
InterceptionInfo.h 1369
IPv6Utils.h 1395
LoadContextInfo.cpp 5061
LoadContextInfo.h 1453
LoadInfo.cpp static 85461
LoadInfo.h Class that provides an nsILoadInfo implementation. 17725
LoadTainting.h 1116 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 8673
mozIThirdPartyUtil.idl Utility functions for determining whether a given URI, channel, or window hierarchy is third party with respect to a known URI. 8849
netCore.h 490
NetUtil.sys.mjs Necko utilities 14908
NetworkConnectivityService.cpp 18175
NetworkConnectivityService.h 2540
NetworkDataCountLayer.cpp 4548
NetworkDataCountLayer.h 834
NetworkInfoServiceImpl.h 567
nsASocketHandler.h 3058
nsAsyncRedirectVerifyHelper.cpp 8918
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 27651
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: 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. 4788
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. 5342
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: 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. 4287
nsIIncrementalStreamLoader.idl Called when new data has arrived on the stream. @param loader the stream loader that loaded the stream. @param ctxt the context parameter of the underlying channel @param dataLength the length of the new data received @param data the contents of the new data received. This method will always be called asynchronously by the nsIIncrementalStreamLoader involved, on the thread that called the loader's init() method. If the observer wants to not accumulate all or portional of the data in the internal buffer, the consumedLength shall be set to the value of the dataLength or less. By default the consumedLength value is assumed 0. The data and dataLength reflect the non-consumed data and will be accumulated if consumedLength is not set. In comparison with onStreamComplete(), the data buffer cannot be adopted if this method returns NS_SUCCESS_ADOPTED_DATA. 4132
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. 14249
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. 2442
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. 4069
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. 60684
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 27828
nsIncrementalStreamLoader.cpp readonly attribute nsIRequest request; 6116
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: and opening a channel on such a sanitize: URI gets the data from, sanitizes it, and returns it, then the sanitize: URI should implement nsINestedURI and return the 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. 4518
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. 1192
nsInputStreamChannel.cpp 2999
nsInputStreamChannel.h 1322
nsInputStreamPump.cpp 26441
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 71372
nsIOService.h 10903
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. 10033
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. 4319
nsIProtocolHandler.idl Protocol handlers are registered with XPCOM under the following CONTRACTID prefix: 11838
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 1545
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 5652
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. 13695
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] [2] [3] 11347
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 37530
nsLoadGroup.h Telemetry 3362
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 137025
nsNetUtil.h 45393
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. 108879
nsSocketTransport2.h 16957
nsSocketTransportService2.cpp 60255
nsSocketTransportService2.h 13621
nsStandardURL.cpp 118779
nsStandardURL.h 20955
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 43826
nsUDPSocket.h 3384
nsURIHashKey.h Hashtable key class to use with nsTHashtable/nsBaseHashtable 1991
nsURLHelper.cpp 41928
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). 13213
nsURLHelperOSX.cpp Mac OS X-specific local file uri parsing 7022
nsURLHelperUnix.cpp Unix-specific local file uri parsing 3518
nsURLHelperWin.cpp Windows-specific local file uri parsing 3457
nsURLParsers.cpp 20037
nsURLParsers.h 4692
PollableEvent.cpp 11560
PollableEvent.h 2376
Predictor.cpp 81750
Predictor.h 18268
PrivateBrowsingChannel.h 3622
ProtocolHandlerInfo.cpp 2924
ProtocolHandlerInfo.h 2239
ProxyAutoConfig.cpp 29698
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; PROXY; 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
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
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 21596
TRRLoadInfo.h 1816