Usage of nsIInputStream Interface

 Additional headers */

attribute nsIInputStream headersStream

 Post data */

attribute nsIInputStream postDataStream

 Get/set the content stream

 This stream contains the data that will be pushed to the channel's
 stream listener.  If the stream is non-blocking and supports the
 nsIAsyncInputStream interface, then the stream will be read directly.
 Otherwise, the stream will be read on a background thread.

 This attribute must be set before the channel is opened, and it may
 only be set once.

 @throws NS_ERROR_IN_PROGRESS if the setter is called after the channel
 has been opened.

attribute nsIInputStream contentStream

 Post Data for the document */

attribute nsIInputStream postData

 The POST data associated with a search submission, wrapped in a MIME
 input stream. May be null.

readonly attribute nsIInputStream postData

 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.

readonly attribute nsIInputStream inputStream

 Get the stream (to be) uploaded by this channel.

readonly attribute nsIInputStream uploadStream

 encodeImage
 Caller provides an image container, and the mime type it should be
 encoded to. We return an input stream for the encoded image data.

 @param aContainer
        An image container.
 @param aMimeType
        Type of encoded image desired (eg "image/png").

nsIInputStream encodeImage(in imgIContainer aContainer, in ACString aMimeType)

 encodeScaledImage
 Caller provides an image container, and the mime type it should be
 encoded to. We return an input stream for the encoded image data.
 The encoded image is scaled to the specified dimensions.

 @param aContainer
        An image container.
 @param aMimeType
        Type of encoded image desired (eg "image/png").
 @param aWidth, aHeight
        The size (in pixels) desired for the resulting image.

nsIInputStream encodeScaledImage(in imgIContainer aContainer, in ACString aMimeType, in long aWidth, in long aHeight)

 Open blocking input stream to cache data.  This will fail if the cache
 entry IS NOT stream based.  Use the stream transport service to
 asynchronously read this stream on a background thread.  The returned
 stream MAY implement nsISeekableStream.

 @param offset
        read starting from this offset into the cached data.  an offset
        beyond the end of the stream has undefined consequences.

 @return blocking, unbuffered input stream.

nsIInputStream openInputStream(in unsigned long offset)

 Synchronously open the channel.

 @return blocking input stream to the channel's data.

 NOTE: nsIChannel implementations are not required to implement this
 method.  Moreover, since this method may block the calling thread, it
 should not be called on a thread that processes UI events.

 NOTE: Implementations should throw NS_ERROR_IN_PROGRESS if the channel
 is reopened.

nsIInputStream open()

 Get stream at specified index.
 @param index   return stream at this index, must be < count
 @return        stream at specified index

nsIInputStream getStream(in unsigned long index)

 Converts a unicode string to an input stream. The bytes in the stream are
 encoded according to the charset attribute.
 The returned stream will be nonblocking.

nsIInputStream convertToInputStream(in AString aString)

 Create a new input stream to read data (written by the singleton output
 stream) from the internal buffer.  Multiple, independent input streams
 can be created.

nsIInputStream newInputStream(in PRInt32 startPosition)

 <b>SYNCRONOUS VERSION</b>
 Converts a stream of one type, to a stream of another type.

 Use this method when you have a stream you want to convert.

 @param aFromStream   The stream representing the original/raw data.
 @param aFromType     The MIME type of aFromStream.
 @param aToType       The MIME type of the returned stream.
 @param aCtxt         Either an opaque context, or a converter specific context
                      (implementation specific).
 @return              The converted stream. NOTE: The returned stream may not
                      already be converted. An efficient stream converter
                      implementation will converter data on demand rather than
                      buffering the converted data until it is used.

nsIInputStream convert(in nsIInputStream aFromStream, in string aFromType, in string aToType, in nsISupports aCtxt)

 <b>SYNCHRONOUS VERSION</b>
 Converts a stream of one type, to a stream of another type.

 Use this method when you have a stream you want to convert.

 @param aFromStream   The stream representing the original/raw data.
 @param aFromType     The MIME type of aFromStream.
 @param aToType       The MIME type of the returned stream.
 @param aContext      Either an opaque context, or a converter specific
                      context (implementation specific).
 @return              The converted stream. NOTE: The returned stream
                      may not already be converted. An efficient stream
                      converter implementation will convert data on
                      demand rather than buffering the converted data
                      until it is used.

nsIInputStream convert(in nsIInputStream aFromStream, in string aFromType, in string aToType, in nsISupports aContext)

 Open an input stream on this transport.

 Flags have the following meaning:

 OPEN_BLOCKING
   If specified, then the resulting stream will have blocking stream
   semantics.  This means that if the stream has no data and is not
   closed, then reading from it will block the calling thread until
   at least one byte is available or until the stream is closed.
   If this flag is NOT specified, then the stream has non-blocking
   stream semantics.  This means that if the stream has no data and is
   not closed, then reading from it returns NS_BASE_STREAM_WOULD_BLOCK.
   In addition, in non-blocking mode, the stream is guaranteed to 
   support nsIAsyncInputStream.  This interface allows the consumer of
   the stream to be notified when the stream can again be read.

 OPEN_UNBUFFERED
   If specified, the resulting stream may not support ReadSegments.
   ReadSegments is only gauranteed to be implemented when this flag is
   NOT specified.

 @param aFlags
        optional transport specific flags.
 @param aSegmentSize
        if OPEN_UNBUFFERED is not set, then this parameter specifies the
        size of each buffer segment (pass 0 to use default value).
 @param aSegmentCount
        if OPEN_UNBUFFERED is not set, then this parameter specifies the
        maximum number of buffer segments (pass 0 to use default value).

nsIInputStream openInputStream(in unsigned long aFlags, in unsigned long aSegmentSize, in unsigned long aSegmentCount)

 Load a specific entry from the archive
 @param file the file to read from
 @param name the name of the xpt within the file
 @return an input stream that will read the raw xpt data from
         the file

nsIInputStream loadEntry(in nsILocalFile file, in string name)

 Returns an input stream containing the contents of the specified zip
 entry.
 @param zipEntry the name of the entry to open the stream from

nsIInputStream getInputStream(in string zipEntry)

 Returns an input stream containing the contents of the specified zip
 entry. If the entry refers to a directory (ends with '/'), a directory stream 
 is opened, otherwise the contents of the file entry is returned.
 @param aJarSpec the Spec of the URI for the JAR (only used for directory streams)
 @param zipEntry the name of the entry to open the stream from

nsIInputStream getInputStreamWithSpec(in AUTF8String aJarSpec, in string zipEntry)

 Writes data into the stream from an input stream.
 Implementer's note: This method is defined by this interface in order
 to allow the output stream to efficiently copy the data from the input
 stream into its internal buffer (if any). If this method was provide
 as an external facility, a separate char* buffer would need to be used
 in order to call the output stream's other Write method.
 @param fromStream the stream from which the data is read
 @param count the maximun number of bytes to write
 @return aWriteCount out parameter to hold the number of
         bytes written. if an error occurs, the writecount
         is undefined

unsigned long writeFrom(in nsIInputStream inStr, in unsigned long count)

 decodeImageData
 Caller provides an input stream and mimetype. We read from the stream
 and decompress it (according to the specified mime type) and return
 the resulting imgIContainer. (If the caller already has a container,
 it can be provided as input to be reused).

 @param aStream
        An input stream for an encoded image file.
 @param aMimeType
        Type of image in the stream.
 @param aContainer
        An imgIContainer holding the decoded image. Specify |null| when
        calling to have one created, otherwise specify a container to
        be reused.

void decodeImageData(in nsIInputStream aStream, in ACString aMimeType, inout imgIContainer aContainer)

 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.

void init(in nsIInputStream aSource, in nsIOutputStream aSink, in nsIEventTarget aTarget, in boolean aSourceBuffered, in boolean aSinkBuffered, in unsigned long aChunkSize, in boolean aCloseSource, in boolean aCloseSink)

 @param fillFromStream - add buffering to this stream
 @param bufferSize     - specifies the maximum buffer size

void init(in nsIInputStream fillFromStream, in unsigned long bufferSize)

 Initialize this stream.
 @param aStream 
        The underlying stream to read from.
 @param aCharset
        The character encoding to use for converting the bytes of the
        stream. A null charset will be interpreted as UTF-8.
 @param aBufferSize
        How many bytes to buffer.
 @param aReplacementChar
        The character to replace unknown byte sequences in the stream
        with. The standard replacement character is U+FFFD.
        A value of 0x0000 will cause an exception to be thrown if unknown
        byte sequences are encountered in the stream.

void init(in nsIInputStream aStream, in string aCharset, in long aBufferSize, in PRUnichar aReplacementChar)

 Calculates and updates a new hash based on a given data stream.

 @param aStream an input stream to read from.

 @param aLen how much to read from the given |aStream|.  Passing
        PR_UINT32_MAX indicates that all data available will be used 
        to update the hash. 

 @throws NS_ERROR_NOT_INITIALIZED if |init| has not been 
         called.

 @throws NS_ERROR_NOT_AVAILABLE if the requested amount of 
         data to be calculated into the hash is not available.

void updateFromStream(in nsIInputStream aStream, in unsigned long aLen)

 Calculates and updates a new hash based on a given data stream.

 @param aStream an input stream to read from.

 @param aLen how much to read from the given |aStream|.  Passing
        PR_UINT32_MAX indicates that all data available will be used 
        to update the hash. 

 @throws NS_ERROR_NOT_INITIALIZED if |init| has not been 
         called.

 @throws NS_ERROR_NOT_AVAILABLE if the requested amount of 
         data to be calculated into the hash is not available.

void updateFromStream(in nsIInputStream aStream, in unsigned long aLen)

 The byte stream passed in is parsed into a DOM document.

 Not accessible from web content.

 @param stream The byte stream whose contents are parsed
 @param charset The character set that was used to encode the byte
                stream. NULL if not specified.
 @param contentLength The number of bytes in the input stream.
 @param contentType The content type of the string - either text/xml,
                    application/xml, or application/xhtml+xml.
                    Must not be NULL.
 @returns The DOM document created as a result of parsing the 
          stream

nsIDOMDocument parseFromStream(in nsIInputStream stream, in string charset, in long contentLength, in string contentType)

 Loads the given URI.  This method is identical to loadURI(...) except
 that its parameter list is broken out instead of being packaged inside
 of an nsIDocShellLoadInfo object...

 @param aURI            - The URI to load.
 @param aReferrer       - Referring URI
 @param aOwner          - Owner (security principal) 
 @param aInheritOwner   - Flag indicating whether the owner of the current
                          document should be inherited if aOwner is null.
 @param aStopActiveDoc  - Flag indicating whether loading the current
                          document should be stopped.
 @param aWindowTarget   - Window target for the load.
 @param aTypeHint       - A hint as to the content-type of the resulting
                          data.  May be null or empty if no hint.
 @param aPostDataStream - Post data stream (if POSTing)
 @param aHeadersStream  - Stream containing "extra" request headers...
 @param aLoadFlags      - Flags to modify load behaviour. Flags are defined
                          in nsIWebNavigation.
 @param aSHEntry        - Active Session History entry (if loading from SH)

[noscript] void internalLoad(in nsIURI aURI, in nsIURI aReferrer, in nsISupports aOwner, in PRUint32 aFlags, in wstring aWindowTarget, in string aTypeHint, in nsIInputStream aPostDataStream, in nsIInputStream aHeadersStream, in unsigned long aLoadFlags, in nsISHEntry aSHEntry, in boolean firstParty, out nsIDocShell aDocShell, out nsIRequest aRequest)

 Loads the given URI.  This method is identical to loadURI(...) except
 that its parameter list is broken out instead of being packaged inside
 of an nsIDocShellLoadInfo object...

 @param aURI            - The URI to load.
 @param aReferrer       - Referring URI
 @param aOwner          - Owner (security principal) 
 @param aInheritOwner   - Flag indicating whether the owner of the current
                          document should be inherited if aOwner is null.
 @param aStopActiveDoc  - Flag indicating whether loading the current
                          document should be stopped.
 @param aWindowTarget   - Window target for the load.
 @param aTypeHint       - A hint as to the content-type of the resulting
                          data.  May be null or empty if no hint.
 @param aPostDataStream - Post data stream (if POSTing)
 @param aHeadersStream  - Stream containing "extra" request headers...
 @param aLoadFlags      - Flags to modify load behaviour. Flags are defined
                          in nsIWebNavigation.
 @param aSHEntry        - Active Session History entry (if loading from SH)

[noscript] void internalLoad(in nsIURI aURI, in nsIURI aReferrer, in nsISupports aOwner, in PRUint32 aFlags, in wstring aWindowTarget, in string aTypeHint, in nsIInputStream aPostDataStream, in nsIInputStream aHeadersStream, in unsigned long aLoadFlags, in nsISHEntry aSHEntry, in boolean firstParty, out nsIDocShell aDocShell, out nsIRequest aRequest)

 Loads a given stream. This will give priority to loading the requested
 stream in the object implementing this interface. If it can't be loaded
 here however, the URL dispatched will go through its normal process of
 content loading.

 @param aStream         - The input stream that provides access to the data
                          to be loaded.  This must be a blocking, threadsafe
                          stream implementation.
 @param aURI            - The URI representing the stream, or null.
 @param aContentType    - The type (MIME) of data being loaded (empty if unknown).
 @param aContentCharset - The charset of the data being loaded (empty if unknown).
 @param aLoadInfo       - This is the extended load info for this load.  This
                          most often will be null, but if you need to do 
                          additional setup for this load you can get a
                          loadInfo object by calling createLoadInfo.  Once
                          you have this object you can set the needed 
                          properties on it and then pass it to loadStream.

[noscript] void loadStream(in nsIInputStream aStream, in nsIURI aURI, in ACString aContentType, in ACString aContentCharset, in nsIDocShellLoadInfo aLoadInfo)

 Parse a feed from an nsIInputStream.

 @param stream The input stream.
 @param uri The base URI.

void parseFromStream(in nsIInputStream stream, in nsIURI uri)

 Test whether an input stream is buffered.  See nsStreamUtils.h
 documentation for NS_InputStreamIsBuffered for the definition of
 "buffered" used here and for edge-case behavior.

 @throws NS_ERROR_INVALID_POINTER if null is passed in.

boolean inputStreamIsBuffered(in nsIInputStream aStream)

 Initialize the input stream pump.

 @param aStream
        contains the data to be read.  if the input stream is non-blocking,
        then it will be QI'd to nsIAsyncInputStream.  if the QI succeeds
        then the stream will be read directly.  otherwise, it will be read
        on a background thread using the stream transport service.
 @param aStreamPos
        specifies the stream offset from which to start reading.  the
        offset value is absolute.  pass -1 to specify the current offset.
        NOTE: this parameter is ignored if the underlying stream does not
        implement nsISeekableStream.
 @param aStreamLen
        specifies how much data to read from the stream.  pass -1 to read
        all data available in the stream.
 @param aSegmentSize
        if the stream transport service is used, then this parameter
        specifies the segment size for the stream transport's buffer.
        pass 0 to specify the default value.
 @param aSegmentCount
        if the stream transport service is used, then this parameter
        specifies the segment count for the stream transport's buffer.
        pass 0 to specify the default value.
 @param aCloseWhenDone
        if true, the input stream will be closed after it has been read.

void init(in nsIInputStream aStream, in long long aStreamPos, in long long aStreamLen, in unsigned long aSegmentSize, in unsigned long aSegmentCount, in boolean aCloseWhenDone)

 Sets data-stream. May not be called once the stream has been started
 to be read.
 The cursor of the new stream should be located at the beginning of the
 stream if the implementation of the nsIMIMEInputStream also is used as
 an nsISeekableStream.
 @param stream  stream containing the data for the stream

void setData(in nsIInputStream stream)

 Appends a stream to the end of the streams. The cursor of the stream
 should be located at the beginning of the stream if the implementation
 of this nsIMultiplexInputStream also is used as an nsISeekableStream.
 @param stream  stream to append

void appendStream(in nsIInputStream stream)

 Insert a stream at specified index.  If the cursor of this stream is at
 the beginning of the stream at index, the cursor will be placed at the
 beginning of the inserted stream instead.
 The cursor of the new stream should be located at the beginning of the
 stream if the implementation of this nsIMultiplexInputStream also is
 used as an nsISeekableStream.
 @param stream  stream to insert
 @param index   index to insert stream at, must be <= count

void insertStream(in nsIInputStream stream, in unsigned long index)

 Writes data into the stream from an input stream.

 @param aFromStream the stream containing the data to be written
 @param aCount the maximum number of bytes to be written

 @return number of bytes written (may be less than aCount)

 @throws NS_BASE_STREAM_WOULD_BLOCK if writing to the output stream would
    block the calling thread (non-blocking mode only)
 @throws <other-error> on failure

 NOTE: This method is defined by this interface in order to allow the
 output stream to efficiently copy the data from the input stream into
 its internal buffer (if any). If this method was provided as an external
 facility, a separate char* buffer would need to be used in order to call
 the output stream's other Write method.

unsigned long writeFrom(in nsIInputStream aFromStream, in unsigned long aCount)

 load a set of name/value pairs from the input stream
 names and values should be in UTF8

void load(in nsIInputStream input)

 Notify the client that data is available in the input stream.  This
 method is called whenver data is written into the input stream by the
 networking library...<BR><BR>
 
 @param aPluginInfo  - plugin stream info
 @param aInputStream - the input stream containing the data. This stream can
 be either a blocking or non-blocking stream.
 @param aLength      - the amount of data that was just pushed into the stream.
 @return             - the return value is currently ignored.

void onDataAvailable(in nsIPluginStreamInfo aPluginInfo, in nsIInputStream aInputStream, in unsigned long aLength)

 @param stream The byte stream whose contents are parsed
 @param charset The character set that was used to encode the byte
                stream. NULL if not specified.
 @param contentType The content type of the string - either text/xml,
                    application/xml, or application/xhtml+xml.
                    Must not be NULL.

void parseFromStream(in nsIInputStream stream, in string charset, in string contentType)

 Additional ways to create an entry */

[noscript] void create(in nsIURI URI, in AString title, in nsIInputStream inputStream, in nsILayoutHistoryState layoutHistoryState, in nsISupports cacheKey, in ACString contentType, in nsISupports owner)

 Wrap the given nsIInputStream with this nsIScriptableInputStream. 

 @param aInputStream parameter providing the stream to wrap 

void init(in nsIInputStream aInputStream)

 Create a unicode stream from an input stream in UTF8.

nsIUnicharInputStream createInstanceFromUTF8Stream(in nsIInputStream aStream)

 Update from a stream.

void updateFromStream(in nsIInputStream aStream, in long aLen)

 <b>SYNCRONOUS VERSION</b>
 Converts a stream of one type, to a stream of another type.

 Use this method when you have a stream you want to convert.

 @param aFromStream   The stream representing the original/raw data.
 @param aFromType     The MIME type of aFromStream.
 @param aToType       The MIME type of the returned stream.
 @param aCtxt         Either an opaque context, or a converter specific context
                      (implementation specific).
 @return              The converted stream. NOTE: The returned stream may not
                      already be converted. An efficient stream converter
                      implementation will converter data on demand rather than
                      buffering the converted data until it is used.

nsIInputStream convert(in nsIInputStream aFromStream, in string aFromType, in string aToType, in nsISupports aCtxt)

 <b>SYNCHRONOUS VERSION</b>
 Converts a stream of one type, to a stream of another type.

 Use this method when you have a stream you want to convert.

 @param aFromStream   The stream representing the original/raw data.
 @param aFromType     The MIME type of aFromStream.
 @param aToType       The MIME type of the returned stream.
 @param aContext      Either an opaque context, or a converter specific
                      context (implementation specific).
 @return              The converted stream. NOTE: The returned stream
                      may not already be converted. An efficient stream
                      converter implementation will convert data on
                      demand rather than buffering the converted data
                      until it is used.

nsIInputStream convert(in nsIInputStream aFromStream, in string aFromType, in string aToType, in nsISupports aContext)

 Called when the next chunk of data (corresponding to the request) may
 be read without blocking the calling thread.  The onDataAvailable impl
 must read exactly |aCount| bytes of data before returning.

 @param aRequest request corresponding to the source of the data
 @param aContext user defined context
 @param aInputStream input stream containing the data chunk
 @param aOffset
        Number of bytes that were sent in previous onDataAvailable calls
        for this request. In other words, the sum of all previous count
        parameters.
        If that number is greater than or equal to 2^32, this parameter
        will be PR_UINT32_MAX (2^32 - 1).
 @param aCount number of bytes available in the stream

 NOTE: The aInputStream parameter must implement readSegments.

 An exception thrown from onDataAvailable has the side-effect of
 causing the request to be canceled.

void onDataAvailable(in nsIRequest aRequest, in nsISupports aContext, in nsIInputStream aInputStream, in unsigned long aOffset, in unsigned long aCount)

 CreateInputTransport

 @param aStream
        The input stream that will be read on a background thread.
        This stream must implement "blocking" stream semantics.
 @param aStartOffset
        The input stream will be read starting from this offset.  Pass
        -1 to read from the current stream offset.  NOTE: this parameter
        is ignored if the stream does not support nsISeekableStream.
 @param aReadLimit
        This parameter limits the number of bytes that will be read from
        the input stream.  Pass -1 to read everything.
 @param aCloseWhenDone
        Specify this flag to have the input stream closed once its
        contents have been completely read.

 @return nsITransport instance.

nsITransport createInputTransport(in nsIInputStream aStream, in long long aStartOffset, in long long aReadLimit, in boolean aCloseWhenDone)

 Sets a stream to be uploaded by this channel.

 Most implementations of this interface require that the stream:
   (1) implement threadsafe addRef and release
   (2) implement nsIInputStream::readSegments
   (3) implement nsISeekableStream::seek

 History here is that we need to support both streams that already have
 headers (e.g., Content-Type and Content-Length) information prepended to
 the stream (by plugins) as well as clients (composer, uploading
 application) that want to upload data streams without any knowledge of
 protocol specifications.  For this reason, we have a special meaning
 for the aContentType parameter (see below).
 
 @param aStream
        The stream to be uploaded by this channel.
 @param aContentType
        If aContentType is empty, the protocol will assume that no
        content headers are to be added to the uploaded stream and that
        any required headers are already encoded in the stream.  In the
        case of HTTP, if this parameter is non-empty, then its value will
        replace any existing Content-Type header on the HTTP request.
        In the case of FTP and FILE, this parameter is ignored.
 @param aContentLength
        A value of -1 indicates that the length of the stream should be
        determined by calling the stream's |available| method.

void setUploadStream(in nsIInputStream aStream, in ACString aContentType, in long aContentLength)

 Save the specified URI to file.

 @param aURI       URI to save to file. Some implementations of this interface
                   may also support <CODE>nsnull</CODE> to imply the currently
                   loaded URI.
 @param aCacheKey  An object representing the URI in the cache or
                   <CODE>nsnull</CODE>.  This can be a necko cache key,
                   an nsIWebPageDescriptor, or the currentDescriptor of an
                   nsIWebPageDescriptor.
 @param aReferrer  The referrer URI to pass with an HTTP request or
                   <CODE>nsnull</CODE>.
 @param aPostData  Post data to pass with an HTTP request or
                   <CODE>nsnull</CODE>.
 @param aExtraHeaders Additional headers to supply with an HTTP request
                   or <CODE>nsnull</CODE>.
 @param aFile      Target file. This may be a nsILocalFile object or an
                   nsIURI object with a file scheme or a scheme that
                   supports uploading (e.g. ftp).

 @see nsILocalFile
 @see nsIURI
 @see nsIInputStream

 @return NS_OK Operation has been started.
 @return NS_ERROR_INVALID_ARG One or more arguments was invalid.

void saveURI(in nsIURI aURI, in nsISupports aCacheKey, in nsIURI aReferrer, in nsIInputStream aPostData, in string aExtraHeaders, in nsISupports aFile)

 Loads a given URI.  This will give priority to loading the requested URI
 in the object implementing	this interface.  If it can't be loaded here
 however, the URI dispatcher will go through its normal process of content
 loading.

 @param aURI
        The URI string to load.  For HTTP and FTP URLs and possibly others,
        characters above U+007F will be converted to UTF-8 and then URL-
        escaped per the rules of RFC 2396.
 @param aLoadFlags
        Flags modifying load behaviour.  This parameter is a bitwise
        combination of the load flags defined above.  (Undefined bits are
        reserved for future use.)  Generally you will pass LOAD_FLAGS_NONE
        for this parameter.
 @param aReferrer
        The referring URI.  If this argument is null, then the referring
        URI will be inferred internally.
 @param aPostData
        If the URI corresponds to a HTTP request, then this stream is
        appended directly to the HTTP request headers.  It may be prefixed
        with additional HTTP headers.  This stream must contain a "\r\n"
        sequence separating any HTTP headers from the HTTP request body.
        This parameter is optional and may be null.
 @param aHeaders
        If the URI corresponds to a HTTP request, then any HTTP headers
        contained in this stream are set on the HTTP request.  The HTTP
        header stream is formatted as:
            ( HEADER "\r\n" )*
        This parameter is optional and may be null.

void loadURI(in wstring aURI, in unsigned long aLoadFlags, in nsIURI aReferrer, in nsIInputStream aPostData, in nsIInputStream aHeaders)

 Loads a given URI.  This will give priority to loading the requested URI
 in the object implementing	this interface.  If it can't be loaded here
 however, the URI dispatcher will go through its normal process of content
 loading.

 @param aURI
        The URI string to load.  For HTTP and FTP URLs and possibly others,
        characters above U+007F will be converted to UTF-8 and then URL-
        escaped per the rules of RFC 2396.
 @param aLoadFlags
        Flags modifying load behaviour.  This parameter is a bitwise
        combination of the load flags defined above.  (Undefined bits are
        reserved for future use.)  Generally you will pass LOAD_FLAGS_NONE
        for this parameter.
 @param aReferrer
        The referring URI.  If this argument is null, then the referring
        URI will be inferred internally.
 @param aPostData
        If the URI corresponds to a HTTP request, then this stream is
        appended directly to the HTTP request headers.  It may be prefixed
        with additional HTTP headers.  This stream must contain a "\r\n"
        sequence separating any HTTP headers from the HTTP request body.
        This parameter is optional and may be null.
 @param aHeaders
        If the URI corresponds to a HTTP request, then any HTTP headers
        contained in this stream are set on the HTTP request.  The HTTP
        header stream is formatted as:
            ( HEADER "\r\n" )*
        This parameter is optional and may be null.

void loadURI(in wstring aURI, in unsigned long aLoadFlags, in nsIURI aReferrer, in nsIInputStream aPostData, in nsIInputStream aHeaders)

 called by the loader for each entry in the archive
 @param itemName the name of this particular item in the archive
 @param index the index of the item inthe archive
 @param stream contains the contents of the xpt file

void foundEntry(in string itemName, in long index, in nsIInputStream xptData)

 Adds data from an input stream to the zip file.

 @param aZipEntry the path of the file entry
 @param aModTime the modification time of the entry in microseconds
 @param aCompression the compression level, 0 is no compression, 9 is best
 @param aStream the input stream to get the data from
 @param aQueue adds the operation to the background queue. Will be
        performed when processQueue is called.

 @throws NS_ERROR_NOT_INITIALIZED if no zip file has been opened
 @throws NS_ERROR_FILE_ALREADY_EXISTS if the path already exists in the zip
 @throws NS_ERROR_IN_PROGRESS if another operation is currently in progress

void addEntryStream(in AUTF8String aZipEntry, in PRTime aModTime, in PRInt32 aCompression, in nsIInputStream aStream, in boolean aQueue)