Name Description Size
ADivertableParentChannel.h 2635
ARefBase.h 824
ArrayBufferInputStream.cpp 3574
ArrayBufferInputStream.h 3014dde6-aa1c-41db-87d0-48764a3710f6 1272
AutoClose.h 1537
BackgroundFileSaver.cpp Buffer size for writing to the output file or reading from the input file. 40731
BackgroundFileSaver.h This file defines two implementations of the nsIBackgroundFileSaver interface. See the "test_backgroundfilesaver.js" file for usage examples. 12167
CaptivePortalService.cpp 12346
CaptivePortalService.h 2053
ChannelDiverterChild.cpp 699
ChannelDiverterChild.h _channeldiverterchild_h_ 716
ChannelDiverterParent.cpp 2002
ChannelDiverterParent.h _channeldiverterparent_h_ 1044
Dashboard.cpp 27870
Dashboard.h Helper methods that pass the JSON to the callback function. 2500
DashboardTypes.h 1199
EventTokenBucket.cpp 11265
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. 5830
FuzzyLayer.cpp These globals control the behavior of our virtual socket: If `gFuzzingAllowRead` is false, any reading on the socket will be denied. This is to ensure that a write has to happen first on a new connection. If `gFuzzingAllowNewConn` is false, any calls to `FuzzyConnect` will fail. We use this to control that only a single connection is opened per buffer. The flag `gFuzzingConnClosed` is set by `FuzzyClose` when the connection is closed. The main thread spins until this becomes true to synchronize the fuzzing iteration between the main thread and the socket thread. 6047
FuzzyLayer.h 551
IOActivityMonitor.cpp 14423
IOActivityMonitor.h IOActivityMonitor_h___ 2348
LoadContextInfo.cpp 5097
LoadContextInfo.h 1494
LoadInfo.cpp 50090
LoadInfo.h Class that provides an nsILoadInfo implementation. 8796
LoadTainting.h 1614
MemoryDownloader.cpp -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*- 2370
MemoryDownloader.h -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*- 1839 8795
mozIThirdPartyUtil.idl Utility functions for determining whether a given URI, channel, or window hierarchy is third party with respect to a known URI. 7597
mozurl 7
netCore.h 490
NetUtil.jsm Necko utilities 16842
NetworkConnectivityService.cpp 8936
NetworkConnectivityService.h 1768
NetworkInfoServiceCocoa.cpp 16k of space should be enough to list all interfaces. Worst case, if it's not then we will error out and fail to list addresses. This should only happen on pathological machines with way too many interfaces. 2685
NetworkInfoServiceImpl.h 577
NetworkInfoServiceLinux.cpp 16k of space should be enough to list all interfaces. Worst case, if it's not then we will error out and fail to list addresses. This should only happen on pathological machines with way too many interfaces. 2643
NetworkInfoServiceWindows.cpp 1656
nsASocketHandler.h 2817
nsAsyncRedirectVerifyHelper.cpp 9414
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. 3635
nsAsyncStreamCopier.cpp An event used to perform initialization off the main thread. 10999
nsAsyncStreamCopier.h 2222
nsAuthInformationHolder.cpp 1414
nsAuthInformationHolder.h This method can be used to initialize the username when the ONLY_PASSWORD flag is set. 1213
nsBase64Encoder.cpp 1316
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 26811
nsBaseChannel.h 12445
nsBaseContentStream.cpp 3694
nsBaseContentStream.h 3393
nsBufferedStreams.cpp nothing 32891
nsBufferedStreams.h 5058
nsDirectoryIndexStream.cpp The converts a filesystem directory into an "HTTP index" stream per Lou Montulli's original spec: 9558
nsDirectoryIndexStream.h aDir will only be used on the calling thread. 1190
nsDNSPrefetch.cpp 4451
nsDNSPrefetch.h 1731
nsDownloader.cpp 2936
nsDownloader.h 964
nsFileStreams.cpp 27076
nsFileStreams.h Flags describing our behavior. See the IDL file for possible values. 9136
nsIApplicationCache.idl Application caches can store a set of namespace entries that affect loads from the application cache. If a load from the cache fails to match an exact cache entry, namespaces entries will be searched for a substring match, and should be applied appropriately. 6788
nsIApplicationCacheChannel.idl Interface implemented by channels that support application caches. 2038
nsIApplicationCacheContainer.idl Interface used by objects that can be associated with an application cache. 603
nsIApplicationCacheService.idl The application cache service manages the set of application cache groups. 3691
nsIArrayBufferInputStream.idl nsIArrayBufferInputStream Provides scriptable methods for initializing a nsIInputStream implementation with an ArrayBuffer. 876
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. 4038
nsIAuthModule.idl Default behavior. 5619
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 3929
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. 4150
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. 1525
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. 7840
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. 1527
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.) 953
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. 7015
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). 5144
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. 2237
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. 15153
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. 4290
nsIChannelWithDivertableParentListener.idl When we are diverting messages from the child to the parent. The nsHttpChannel and nsFtpChannel must know that there is a ChannelParent to be able to suspend message delivery if the channel is suspended. 1584
nsIChildChannel.idl Implemented by content side of IPC protocols. 1234
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. 1442
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. The default gecko HTTP/1 stack makes Followers wait for Leaders to complete before dispatching followers. Other classes run in parallel - neither being blocked nor blocking. All grouping is done based on the Load Group - separate load groups proceed independently. HTTP/2 does not use the load group, but prioritization is done per HTTP/2 session. HTTP/2 dispatches all the requests as soon as possible. The various classes are assigned logical priority dependency groups and then transactions of that class depend on the group. In this model Followers block on Leaders and Speculative depends on Background. See Http2Stream.cpp for weighting details. 2282
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 2232
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 1057
nsIDeprecationWarner.idl Interface for warning about deprecated operations. Consumers should attach this interface to the channel's notification callbacks/loadgroup. 910
nsIDHCPClient.idl This interface allows the proxy code to access the DHCP Options in a platform-specific way 640
nsIDivertableChannel.idl A channel implementing this interface allows diverting from an nsIStreamListener in the child process to one in the parent. 3158
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. 1995
nsIEncodedChannel.idl A channel interface which allows special handling of encoded content 2237
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. 8998
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. 782
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 1064
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. 4096
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. 2156
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. 2853
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. 11316
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. 2545
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. 4035
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. 1534
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. 43066
nsIMIMEInputStream.idl The MIME stream separates headers and a datastream. It also allows automatic creation of the content-length header. 1677
nsIMultiPartChannel.idl An interface to access the the base channel associated with a MultiPartChannel. 1067
nsIncrementalDownload.cpp 26046
nsIncrementalStreamLoader.cpp readonly attribute nsIRequest request; 6137
nsIncrementalStreamLoader.h 1712
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. 2674
nsINetAddr.idl nsINetAddr This interface represents a native NetAddr struct in a readonly interface. 2528
nsINetUtil.idl nsINetUtil provides various network-related utility methods. 8962
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. 1427
nsINetworkInfoService.idl Listener for getting list of addresses. 1901
nsINetworkInterceptController.idl Interface allowing the nsIInterceptedChannel to callback when it is done reading from the body stream. 9128
nsINetworkLinkService.idl Network link status monitoring service. 3372
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. 6978
nsINetworkPredictorVerifier.idl nsINetworkPredictorVerifier - used for testing the network predictor to ensure it does what we expect it to do. 1192
nsInputStreamChannel.cpp 2862
nsInputStreamChannel.h 1262
nsInputStreamPump.cpp 24366
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. 3382
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 60413
nsIOService.h 9787
nsIParentChannel.idl Implemented by chrome side of IPC protocols. 2543
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. 2651
nsIPermission.idl This interface defines a "permission" object, used to specify allowed/blocked objects from user-specified sites (cookies, images etc). 2805
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. 18724
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. 3331
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. 4143
nsIProtocolHandler.idl Protocol handlers are registered with XPCOM under the following CONTRACTID prefix: 13102
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. 4535
nsIProtocolProxyService.idl nsIProtocolProxyService provides methods to access information about various network proxies. 12934
nsIProtocolProxyService2.idl An extension of nsIProtocolProxyService 1272
nsIProxiedChannel.idl An interface for accessing the proxy info that a channel was constructed with. @see nsIProxiedProtocolHandler 726
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. 2894
nsIRandomGenerator.idl Interface used to generate random data. @threadsafe 765
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. 2660
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). 806
nsIRequest.idl nsIRequest 8942
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. 5283
nsIRequestObserver.idl nsIRequestObserver 1225
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. 1783
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 765
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. 10382
nsISimpleStreamListener.idl A simple stream listener can be used with AsyncRead to supply data to a output stream. 829
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. 1843
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. 11549
nsISocketTransportService.idl Creates a transport for a specified host and port. @param aSocketTypes array of socket type strings. null if using default socket type. @param aTypeCount specifies length of aSocketTypes. @param aHost specifies the target hostname or IP address literal of the peer for this socket. @param aPort specifies the target port of the peer for this socket. @param aProxyInfo specifies the transport-layer proxy type to use. null if no proxy. used for communicating information about proxies like SOCKS (which are transparent to upper protocols). @see nsIProxiedProtocolHandler @see nsIProtocolProxyService::GetProxyInfo NOTE: this function can be called from any thread 6082
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 such as nsIBadCertListener. May be null. 2721
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. 1957
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. 2909
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. 1716
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. 1938
nsIThreadRetargetableRequest.idl nsIThreadRetargetableRequest Should be implemented by requests that support retargeting delivery of data off the main thread. 1632
nsIThreadRetargetableStreamListener.idl nsIThreadRetargetableStreamListener To be used by classes which implement nsIStreamListener and whose OnDataAvailable callback may be retargeted for delivery off the main thread. 1351
nsIThrottledInputChannel.idl An instance of this interface can be used to throttle the uploads of a group of associated channels. 2679
nsITimedChannel.idl 5107
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|. 6031
nsITraceableChannel.idl A channel implementing this interface allows one to intercept its data by inserting intermediate stream listeners. 1454
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. 6973
nsIUDPSocket.idl nsIUDPSocket An interface to a UDP socket that can accept incoming connections. 12144
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. 2444
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. 2881
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] 11305
nsIURIMutator.idl 21860
nsIURIMutatorUtils.cpp 618
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 5654
nsIURLParser.idl nsIURLParser specifies the interface to an URL parser that attempts to follow the definitions of RFC 2396. 4189
nsLoadGroup.cpp 29953
nsLoadGroup.h Telemetry 2669
nsMediaFragmentURIParser.cpp 9252
nsMediaFragmentURIParser.h 3799
nsMIMEInputStream.cpp The MIME stream separates headers and a datastream. It also allows automatic creation of the content-length header. 17651
nsMIMEInputStream.h The MIME stream separates headers and a datastream. It also allows automatic creation of the content-length header. 1046
nsNetAddr.cpp Makes a copy of |addr| 3368
nsNetAddr.h additional members 653
nsNetSegmentUtils.h applies defaults to segment params in a consistent way. 678
nsNetUtil.cpp = 0 106215
nsNetUtil.h 41714
nsNetworkInfoService.cpp 2745
nsNetworkInfoService.h 1164
nsPACMan.cpp 28085
nsPACMan.h This class defines a callback interface used by AsyncGetProxyForURI. 8805
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. 1687
nsPreloadedStream.cpp 3309
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. 1621
nsProtocolProxyService.cpp 75313
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. 12859
nsProxyInfo.cpp 2377
nsProxyInfo.h ed42f751-825e-4cc2-abeb-3670711a8b85 2128
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 1295
nsRedirectHistoryEntry.h 895
nsRequestObserverProxy.cpp 6353
nsRequestObserverProxy.h 1441
nsSerializationHelper.cpp 1856
nsSerializationHelper.h @file Helper functions for (de)serializing objects to/from ASCII strings. 878
nsServerSocket.cpp 16502
nsServerSocket.h 1981
nsSimpleNestedURI.cpp virtual 6492
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. 3521
nsSimpleStreamListener.cpp 2364
nsSimpleStreamListener.h 900
nsSimpleURI.cpp static 19265
nsSimpleURI.h 0b9bb0c2-fee6-470b-b9b9-9fd9462b5e19 5311
nsSocketTransport2.cpp Following inclusions required for keepalive config not supported by NSPR. 114085
nsSocketTransport2.h 15620
nsSocketTransportService2.cpp 54566
nsSocketTransportService2.h 11023
nsStandardURL.cpp 106428
nsStandardURL.h internal -- HPUX compiler can't handle this being private 19180
nsStreamListenerTee.cpp 3772
nsStreamListenerTee.h 1154
nsStreamListenerWrapper.cpp 878
nsStreamListenerWrapper.h 1259
nsStreamLoader.cpp 4199
nsStreamLoader.h 1680
nsStreamTransportService.cpp nsITransport * 10016
nsStreamTransportService.h 1193
nsSyncStreamListener.cpp 4955
nsSyncStreamListener.h 1173
nsTransportUtils.cpp 4009
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 41477
nsUDPSocket.h 3175
nsURIHashKey.h Hashtable key class to use with nsTHashtable/nsBaseHashtable 1871
nsURLHelper.cpp 31847
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). 9508
nsURLHelperOSX.cpp Mac OS X-specific local file uri parsing 7043
nsURLHelperUnix.cpp Unix-specific local file uri parsing 3446
nsURLHelperWin.cpp Windows-specific local file uri parsing 3355
nsURLParsers.cpp 19926
nsURLParsers.h 4726
PartiallySeekableInputStream.cpp 12777
PartiallySeekableInputStream.h 3155
PollableEvent.cpp 11668
PollableEvent.h 2317
Predictor.cpp 87110
Predictor.h 18365
PrivateBrowsingChannel.h 3692
ProxyAutoConfig.cpp 32697
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. 3406
RedirectChannelRegistrar.cpp 2422
RedirectChannelRegistrar.h 1316
ReferrerPolicy.h spec tokens: never no-referrer 4628
RequestContextService.cpp 16826
RequestContextService.h 1213
rust-helper 2
ShutdownLayer.cpp 2219
ShutdownLayer.h SHUTDOWN_H___ 669
SimpleBuffer.cpp 2320
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. 1466
SimpleChannel.cpp 4399
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. 4052
SimpleChannelParent.cpp 2823
SimpleChannelParent.h NS_SIMPLECHANNELPARENT_H 1198
TCPFastOpen.h This is an abstract class for TCP Fast Open - TFO (RFC7413). It is not always safe to use Fast Open. It can be use for requests that are replayable. Middle boxes can block or reset connections that use TFO, therefore a backup connection will be prepared with a delay. In case of blocking such a connection tcp socket will terminate only after a timeout, therefore a backup connection is needed. If connection is refuse the same socketTransport will retry. This is implemented by nsHalfopenSocket. 1761
TCPFastOpenLayer.cpp For the TCP Fast Open it is necessary to send all data that can fit into the first packet on a single sendto function call. Consecutive calls will not have an effect. Therefore TCPFastOpenLayer will collect some data before calling sendto. Necko and nss will call PR_Write multiple times with small amount of data. TCPFastOpenLayer has 4 states: WAITING_FOR_CONNECT: This is before connect is call. A call of recv, send or getpeername will return PR_NOT_CONNECTED_ERROR. After connect is call the state transfers into COLLECT_DATA_FOR_FIRST_PACKET. COLLECT_DATA_FOR_FIRST_PACKET: In this state all data received by send function calls will be stored in a buffer. If transaction do not have any more data ready to be sent or the buffer is full, TCPFastOpenFinish is call. TCPFastOpenFinish sends the collected data using sendto function and the state transfers to WAITING_FOR_CONNECTCONTINUE. If an error occurs during sendto, the error is reported by the TCPFastOpenFinish return values. nsSocketTransfer is the only caller of TCPFastOpenFinish; it knows how to interpreter these errors. WAITING_FOR_CONNECTCONTINUE: connectcontinue transfers from this state to CONNECTED. Any other function (e.g. send, recv) returns PR_WOULD_BLOCK_ERROR. CONNECTED: The size of mFirstPacketBuf is 1440/1460 (RFC7413 recomends that packet does exceeds these sizes). SendTo does not have to consume all buffered data and some data can be still in mFirstPacketBuf. Before sending any new data we need to send the remaining buffered data. 19601
TCPFastOpenLayer.h This layer must be placed just above PR-tcp socket, i.e. it must be under nss layer. At the beginning of TCPFastOpenLayer.cpp there is explanation what this layer do. 4371
ThrottleQueue.cpp 9469
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. 1788
Tickler.cpp 6208
Tickler.h 3838
TLSServerSocket.cpp 13815
TLSServerSocket.h 2410