PageRenderTime 37ms CodeModel.GetById 19ms app.highlight 11ms RepoModel.GetById 2ms app.codeStats 0ms

/gecko_api/include/nsIChannel.h

http://firefox-mac-pdf.googlecode.com/
C++ Header | 452 lines | 178 code | 54 blank | 220 comment | 0 complexity | 22e85b5e7209ba0d74e81ef79f72d737 MD5 | raw file
  1/*
  2 * DO NOT EDIT.  THIS FILE IS GENERATED FROM /builds/tinderbox/XR-Trunk/Darwin_8.8.4_Depend/mozilla/netwerk/base/public/nsIChannel.idl
  3 */
  4
  5#ifndef __gen_nsIChannel_h__
  6#define __gen_nsIChannel_h__
  7
  8
  9#ifndef __gen_nsIRequest_h__
 10#include "nsIRequest.h"
 11#endif
 12
 13/* For IDL files that don't want to include root IDL files. */
 14#ifndef NS_NO_VTABLE
 15#define NS_NO_VTABLE
 16#endif
 17class nsIURI; /* forward declaration */
 18
 19class nsIInterfaceRequestor; /* forward declaration */
 20
 21class nsIInputStream; /* forward declaration */
 22
 23class nsIStreamListener; /* forward declaration */
 24
 25
 26/* starting interface:    nsIChannel */
 27#define NS_ICHANNEL_IID_STR "c63a055a-a676-4e71-bf3c-6cfa11082018"
 28
 29#define NS_ICHANNEL_IID \
 30  {0xc63a055a, 0xa676, 0x4e71, \
 31    { 0xbf, 0x3c, 0x6c, 0xfa, 0x11, 0x08, 0x20, 0x18 }}
 32
 33/**
 34 * The nsIChannel interface allows clients to construct "GET" requests for
 35 * specific protocols, and manage them in a uniform way.  Once a channel is
 36 * created (via nsIIOService::newChannel), parameters for that request may
 37 * be set by using the channel attributes, or by QI'ing to a subclass of
 38 * nsIChannel for protocol-specific parameters.  Then, the URI can be fetched
 39 * by calling nsIChannel::open or nsIChannel::asyncOpen.
 40 *
 41 * After a request has been completed, the channel is still valid for accessing
 42 * protocol-specific results.  For example, QI'ing to nsIHttpChannel allows
 43 * response headers to be retrieved for the corresponding http transaction. 
 44 *
 45 * @status FROZEN
 46 */
 47class NS_NO_VTABLE NS_SCRIPTABLE nsIChannel : public nsIRequest {
 48 public: 
 49
 50  NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICHANNEL_IID)
 51
 52  /**
 53     * The original URI used to construct the channel. This is used in the case
 54     * of a redirect or URI "resolution" (e.g. resolving a resource: URI to a
 55     * file: URI) so that the original pre-redirect URI can still be obtained. 
 56     *
 57     * NOTE: this is distinctly different from the http Referer (referring URI),
 58     * which is typically the page that contained the original URI (accessible
 59     * from nsIHttpChannel).
 60     */
 61  /* attribute nsIURI originalURI; */
 62  NS_SCRIPTABLE NS_IMETHOD GetOriginalURI(nsIURI * *aOriginalURI) = 0;
 63  NS_SCRIPTABLE NS_IMETHOD SetOriginalURI(nsIURI * aOriginalURI) = 0;
 64
 65  /**
 66     * The URI corresponding to the channel.  Its value is immutable.
 67     */
 68  /* readonly attribute nsIURI URI; */
 69  NS_SCRIPTABLE NS_IMETHOD GetURI(nsIURI * *aURI) = 0;
 70
 71  /**
 72     * The owner, corresponding to the entity that is responsible for this
 73     * channel.  Used by the security manager to grant or deny privileges to
 74     * mobile code loaded from this channel.
 75     *
 76     * NOTE: this is a strong reference to the owner, so if the owner is also
 77     * holding a strong reference to the channel, care must be taken to 
 78     * explicitly drop its reference to the channel.
 79     */
 80  /* attribute nsISupports owner; */
 81  NS_SCRIPTABLE NS_IMETHOD GetOwner(nsISupports * *aOwner) = 0;
 82  NS_SCRIPTABLE NS_IMETHOD SetOwner(nsISupports * aOwner) = 0;
 83
 84  /**
 85     * The notification callbacks for the channel.  This is set by clients, who
 86     * wish to provide a means to receive progress, status and protocol-specific 
 87     * notifications.  If this value is NULL, the channel implementation may use
 88     * the notification callbacks from its load group.  The channel may also
 89     * query the notification callbacks from its load group if its notification
 90     * callbacks do not supply the requested interface.
 91     * 
 92     * Interfaces commonly requested include: nsIProgressEventSink, nsIPrompt,
 93     * and nsIAuthPrompt/nsIAuthPrompt2.
 94     *
 95     * When the channel is done, it must not continue holding references to
 96     * this object.
 97     *
 98     * NOTE: A channel implementation should take care when "caching" an
 99     * interface pointer queried from its notification callbacks.  If the
100     * notification callbacks are changed, then a cached interface pointer may
101     * become invalid and may therefore need to be re-queried.
102     */
103  /* attribute nsIInterfaceRequestor notificationCallbacks; */
104  NS_SCRIPTABLE NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks) = 0;
105  NS_SCRIPTABLE NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor * aNotificationCallbacks) = 0;
106
107  /**
108     * Transport-level security information (if any) corresponding to the channel.
109     */
110  /* readonly attribute nsISupports securityInfo; */
111  NS_SCRIPTABLE NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) = 0;
112
113  /**
114     * The MIME type of the channel's content if available. 
115     * 
116     * NOTE: the content type can often be wrongly specified (e.g., wrong file
117     * extension, wrong MIME type, wrong document type stored on a server, etc.),
118     * and the caller most likely wants to verify with the actual data.
119     *
120     * Setting contentType before the channel has been opened provides a hint
121     * to the channel as to what the MIME type is.  The channel may ignore this
122     * hint in deciding on the actual MIME type that it will report.
123     *
124     * Setting contentType after onStartRequest has been fired or after open()
125     * is called will override the type determined by the channel.
126     *
127     * Setting contentType between the time that asyncOpen() is called and the
128     * time when onStartRequest is fired has undefined behavior at this time.
129     *
130     * The value of the contentType attribute is a lowercase string.  A value
131     * assigned to this attribute will be parsed and normalized as follows:
132     *  1- any parameters (delimited with a ';') will be stripped.
133     *  2- if a charset parameter is given, then its value will replace the
134     *     the contentCharset attribute of the channel.
135     *  3- the stripped contentType will be lowercased.
136     * Any implementation of nsIChannel must follow these rules.
137     */
138  /* attribute ACString contentType; */
139  NS_SCRIPTABLE NS_IMETHOD GetContentType(nsACString & aContentType) = 0;
140  NS_SCRIPTABLE NS_IMETHOD SetContentType(const nsACString & aContentType) = 0;
141
142  /**
143     * The character set of the channel's content if available and if applicable.
144     * This attribute only applies to textual data.
145     *
146     * The value of the contentCharset attribute is a mixedcase string.
147     */
148  /* attribute ACString contentCharset; */
149  NS_SCRIPTABLE NS_IMETHOD GetContentCharset(nsACString & aContentCharset) = 0;
150  NS_SCRIPTABLE NS_IMETHOD SetContentCharset(const nsACString & aContentCharset) = 0;
151
152  /**
153     * The length of the data associated with the channel if available.  A value
154     * of -1 indicates that the content length is unknown.
155     *
156     * Callers should prefer getting the "content-length" property
157     * as 64-bit value by QIing the channel to nsIPropertyBag2,
158     * if that interface is exposed by the channel.
159     */
160  /* attribute long contentLength; */
161  NS_SCRIPTABLE NS_IMETHOD GetContentLength(PRInt32 *aContentLength) = 0;
162  NS_SCRIPTABLE NS_IMETHOD SetContentLength(PRInt32 aContentLength) = 0;
163
164  /**
165     * Synchronously open the channel.
166     *
167     * @return blocking input stream to the channel's data.
168     *
169     * NOTE: nsIChannel implementations are not required to implement this
170     * method.  Moreover, since this method may block the calling thread, it
171     * should not be called on a thread that processes UI events.
172     *
173     * NOTE: Implementations should throw NS_ERROR_IN_PROGRESS if the channel
174     * is reopened.
175     */
176  /* nsIInputStream open (); */
177  NS_SCRIPTABLE NS_IMETHOD Open(nsIInputStream **_retval) = 0;
178
179  /**
180     * Asynchronously open this channel.  Data is fed to the specified stream
181     * listener as it becomes available.  The stream listener's methods are
182     * called on the thread that calls asyncOpen and are not called until
183     * after asyncOpen returns.  If asyncOpen returns successfully, the
184     * channel promises to call at least onStartRequest and onStopRequest.
185     *
186     * If the nsIRequest object passed to the stream listener's methods is not
187     * this channel, an appropriate onChannelRedirect notification needs to be
188     * sent to the notification callbacks before onStartRequest is called.
189     * Once onStartRequest is called, all following method calls on aListener
190     * will get the request that was passed to onStartRequest.
191     *
192     * If the channel's and loadgroup's notification callbacks do not provide
193     * an nsIChannelEventSink when onChannelRedirect would be called, that's
194     * equivalent to having called onChannelRedirect.
195     *
196     * If asyncOpen returns successfully, the channel is responsible for
197     * keeping itself alive until it has called onStopRequest on aListener or
198     * called onChannelRedirect.
199     *
200     * Implementations are allowed to synchronously add themselves to the
201     * associated load group (if any).
202     *
203     * NOTE: Implementations should throw NS_ERROR_ALREADY_OPENED if the
204     * channel is reopened.
205     *
206     * @param aListener the nsIStreamListener implementation
207     * @param aContext an opaque parameter forwarded to aListener's methods
208     * @see nsIChannelEventSink for onChannelRedirect
209     */
210  /* void asyncOpen (in nsIStreamListener aListener, in nsISupports aContext); */
211  NS_SCRIPTABLE NS_IMETHOD AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext) = 0;
212
213  /**************************************************************************
214     * Channel specific load flags:
215     *
216     * Bits 22-31 are reserved for future use by this interface or one of its
217     * derivatives (e.g., see nsICachingChannel).
218     */
219/**
220     * Set (e.g., by the docshell) to indicate whether or not the channel
221     * corresponds to a document URI.
222     */
223  enum { LOAD_DOCUMENT_URI = 65536U };
224
225  /** 
226     * If the end consumer for this load has been retargeted after discovering 
227     * its content, this flag will be set:
228     */
229  enum { LOAD_RETARGETED_DOCUMENT_URI = 131072U };
230
231  /**
232     * This flag is set to indicate that this channel is replacing another
233     * channel.  This means that:
234     *
235     * 1) the stream listener this channel will be notifying was initially
236     *    passed to the asyncOpen method of some other channel
237     *
238     *   and
239     *
240     * 2) this channel's URI is a better identifier of the resource being
241     *    accessed than this channel's originalURI.
242     *
243     * This flag can be set, for example, for redirects or for cases when a
244     * single channel has multiple parts to it (and thus can follow
245     * onStopRequest with another onStartRequest/onStopRequest pair, each pair
246     * for a different request).
247     */
248  enum { LOAD_REPLACE = 262144U };
249
250  /**
251     * Set (e.g., by the docshell) to indicate whether or not the channel
252     * corresponds to an initial document URI load (e.g., link click).
253     */
254  enum { LOAD_INITIAL_DOCUMENT_URI = 524288U };
255
256  /**
257     * Set (e.g., by the URILoader) to indicate whether or not the end consumer
258     * for this load has been determined.
259     */
260  enum { LOAD_TARGETED = 1048576U };
261
262  /**
263     * If this flag is set, the channel should call the content sniffers as
264     * described in nsNetCID.h about NS_CONTENT_SNIFFER_CATEGORY.
265     *
266     * Note: Channels may ignore this flag; however, new channel implementations
267     * should only do so with good reason.
268     */
269  enum { LOAD_CALL_CONTENT_SNIFFERS = 2097152U };
270
271};
272
273  NS_DEFINE_STATIC_IID_ACCESSOR(nsIChannel, NS_ICHANNEL_IID)
274
275/* Use this macro when declaring classes that implement this interface. */
276#define NS_DECL_NSICHANNEL \
277  NS_SCRIPTABLE NS_IMETHOD GetOriginalURI(nsIURI * *aOriginalURI); \
278  NS_SCRIPTABLE NS_IMETHOD SetOriginalURI(nsIURI * aOriginalURI); \
279  NS_SCRIPTABLE NS_IMETHOD GetURI(nsIURI * *aURI); \
280  NS_SCRIPTABLE NS_IMETHOD GetOwner(nsISupports * *aOwner); \
281  NS_SCRIPTABLE NS_IMETHOD SetOwner(nsISupports * aOwner); \
282  NS_SCRIPTABLE NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks); \
283  NS_SCRIPTABLE NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor * aNotificationCallbacks); \
284  NS_SCRIPTABLE NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo); \
285  NS_SCRIPTABLE NS_IMETHOD GetContentType(nsACString & aContentType); \
286  NS_SCRIPTABLE NS_IMETHOD SetContentType(const nsACString & aContentType); \
287  NS_SCRIPTABLE NS_IMETHOD GetContentCharset(nsACString & aContentCharset); \
288  NS_SCRIPTABLE NS_IMETHOD SetContentCharset(const nsACString & aContentCharset); \
289  NS_SCRIPTABLE NS_IMETHOD GetContentLength(PRInt32 *aContentLength); \
290  NS_SCRIPTABLE NS_IMETHOD SetContentLength(PRInt32 aContentLength); \
291  NS_SCRIPTABLE NS_IMETHOD Open(nsIInputStream **_retval); \
292  NS_SCRIPTABLE NS_IMETHOD AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext); \
293
294/* Use this macro to declare functions that forward the behavior of this interface to another object. */
295#define NS_FORWARD_NSICHANNEL(_to) \
296  NS_SCRIPTABLE NS_IMETHOD GetOriginalURI(nsIURI * *aOriginalURI) { return _to GetOriginalURI(aOriginalURI); } \
297  NS_SCRIPTABLE NS_IMETHOD SetOriginalURI(nsIURI * aOriginalURI) { return _to SetOriginalURI(aOriginalURI); } \
298  NS_SCRIPTABLE NS_IMETHOD GetURI(nsIURI * *aURI) { return _to GetURI(aURI); } \
299  NS_SCRIPTABLE NS_IMETHOD GetOwner(nsISupports * *aOwner) { return _to GetOwner(aOwner); } \
300  NS_SCRIPTABLE NS_IMETHOD SetOwner(nsISupports * aOwner) { return _to SetOwner(aOwner); } \
301  NS_SCRIPTABLE NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks) { return _to GetNotificationCallbacks(aNotificationCallbacks); } \
302  NS_SCRIPTABLE NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor * aNotificationCallbacks) { return _to SetNotificationCallbacks(aNotificationCallbacks); } \
303  NS_SCRIPTABLE NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) { return _to GetSecurityInfo(aSecurityInfo); } \
304  NS_SCRIPTABLE NS_IMETHOD GetContentType(nsACString & aContentType) { return _to GetContentType(aContentType); } \
305  NS_SCRIPTABLE NS_IMETHOD SetContentType(const nsACString & aContentType) { return _to SetContentType(aContentType); } \
306  NS_SCRIPTABLE NS_IMETHOD GetContentCharset(nsACString & aContentCharset) { return _to GetContentCharset(aContentCharset); } \
307  NS_SCRIPTABLE NS_IMETHOD SetContentCharset(const nsACString & aContentCharset) { return _to SetContentCharset(aContentCharset); } \
308  NS_SCRIPTABLE NS_IMETHOD GetContentLength(PRInt32 *aContentLength) { return _to GetContentLength(aContentLength); } \
309  NS_SCRIPTABLE NS_IMETHOD SetContentLength(PRInt32 aContentLength) { return _to SetContentLength(aContentLength); } \
310  NS_SCRIPTABLE NS_IMETHOD Open(nsIInputStream **_retval) { return _to Open(_retval); } \
311  NS_SCRIPTABLE NS_IMETHOD AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext) { return _to AsyncOpen(aListener, aContext); } \
312
313/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
314#define NS_FORWARD_SAFE_NSICHANNEL(_to) \
315  NS_SCRIPTABLE NS_IMETHOD GetOriginalURI(nsIURI * *aOriginalURI) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetOriginalURI(aOriginalURI); } \
316  NS_SCRIPTABLE NS_IMETHOD SetOriginalURI(nsIURI * aOriginalURI) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetOriginalURI(aOriginalURI); } \
317  NS_SCRIPTABLE NS_IMETHOD GetURI(nsIURI * *aURI) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetURI(aURI); } \
318  NS_SCRIPTABLE NS_IMETHOD GetOwner(nsISupports * *aOwner) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetOwner(aOwner); } \
319  NS_SCRIPTABLE NS_IMETHOD SetOwner(nsISupports * aOwner) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetOwner(aOwner); } \
320  NS_SCRIPTABLE NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetNotificationCallbacks(aNotificationCallbacks); } \
321  NS_SCRIPTABLE NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor * aNotificationCallbacks) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetNotificationCallbacks(aNotificationCallbacks); } \
322  NS_SCRIPTABLE NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSecurityInfo(aSecurityInfo); } \
323  NS_SCRIPTABLE NS_IMETHOD GetContentType(nsACString & aContentType) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetContentType(aContentType); } \
324  NS_SCRIPTABLE NS_IMETHOD SetContentType(const nsACString & aContentType) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetContentType(aContentType); } \
325  NS_SCRIPTABLE NS_IMETHOD GetContentCharset(nsACString & aContentCharset) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetContentCharset(aContentCharset); } \
326  NS_SCRIPTABLE NS_IMETHOD SetContentCharset(const nsACString & aContentCharset) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetContentCharset(aContentCharset); } \
327  NS_SCRIPTABLE NS_IMETHOD GetContentLength(PRInt32 *aContentLength) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetContentLength(aContentLength); } \
328  NS_SCRIPTABLE NS_IMETHOD SetContentLength(PRInt32 aContentLength) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetContentLength(aContentLength); } \
329  NS_SCRIPTABLE NS_IMETHOD Open(nsIInputStream **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->Open(_retval); } \
330  NS_SCRIPTABLE NS_IMETHOD AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext) { return !_to ? NS_ERROR_NULL_POINTER : _to->AsyncOpen(aListener, aContext); } \
331
332#if 0
333/* Use the code below as a template for the implementation class for this interface. */
334
335/* Header file */
336class nsChannel : public nsIChannel
337{
338public:
339  NS_DECL_ISUPPORTS
340  NS_DECL_NSICHANNEL
341
342  nsChannel();
343
344private:
345  ~nsChannel();
346
347protected:
348  /* additional members */
349};
350
351/* Implementation file */
352NS_IMPL_ISUPPORTS1(nsChannel, nsIChannel)
353
354nsChannel::nsChannel()
355{
356  /* member initializers and constructor code */
357}
358
359nsChannel::~nsChannel()
360{
361  /* destructor code */
362}
363
364/* attribute nsIURI originalURI; */
365NS_IMETHODIMP nsChannel::GetOriginalURI(nsIURI * *aOriginalURI)
366{
367    return NS_ERROR_NOT_IMPLEMENTED;
368}
369NS_IMETHODIMP nsChannel::SetOriginalURI(nsIURI * aOriginalURI)
370{
371    return NS_ERROR_NOT_IMPLEMENTED;
372}
373
374/* readonly attribute nsIURI URI; */
375NS_IMETHODIMP nsChannel::GetURI(nsIURI * *aURI)
376{
377    return NS_ERROR_NOT_IMPLEMENTED;
378}
379
380/* attribute nsISupports owner; */
381NS_IMETHODIMP nsChannel::GetOwner(nsISupports * *aOwner)
382{
383    return NS_ERROR_NOT_IMPLEMENTED;
384}
385NS_IMETHODIMP nsChannel::SetOwner(nsISupports * aOwner)
386{
387    return NS_ERROR_NOT_IMPLEMENTED;
388}
389
390/* attribute nsIInterfaceRequestor notificationCallbacks; */
391NS_IMETHODIMP nsChannel::GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks)
392{
393    return NS_ERROR_NOT_IMPLEMENTED;
394}
395NS_IMETHODIMP nsChannel::SetNotificationCallbacks(nsIInterfaceRequestor * aNotificationCallbacks)
396{
397    return NS_ERROR_NOT_IMPLEMENTED;
398}
399
400/* readonly attribute nsISupports securityInfo; */
401NS_IMETHODIMP nsChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
402{
403    return NS_ERROR_NOT_IMPLEMENTED;
404}
405
406/* attribute ACString contentType; */
407NS_IMETHODIMP nsChannel::GetContentType(nsACString & aContentType)
408{
409    return NS_ERROR_NOT_IMPLEMENTED;
410}
411NS_IMETHODIMP nsChannel::SetContentType(const nsACString & aContentType)
412{
413    return NS_ERROR_NOT_IMPLEMENTED;
414}
415
416/* attribute ACString contentCharset; */
417NS_IMETHODIMP nsChannel::GetContentCharset(nsACString & aContentCharset)
418{
419    return NS_ERROR_NOT_IMPLEMENTED;
420}
421NS_IMETHODIMP nsChannel::SetContentCharset(const nsACString & aContentCharset)
422{
423    return NS_ERROR_NOT_IMPLEMENTED;
424}
425
426/* attribute long contentLength; */
427NS_IMETHODIMP nsChannel::GetContentLength(PRInt32 *aContentLength)
428{
429    return NS_ERROR_NOT_IMPLEMENTED;
430}
431NS_IMETHODIMP nsChannel::SetContentLength(PRInt32 aContentLength)
432{
433    return NS_ERROR_NOT_IMPLEMENTED;
434}
435
436/* nsIInputStream open (); */
437NS_IMETHODIMP nsChannel::Open(nsIInputStream **_retval)
438{
439    return NS_ERROR_NOT_IMPLEMENTED;
440}
441
442/* void asyncOpen (in nsIStreamListener aListener, in nsISupports aContext); */
443NS_IMETHODIMP nsChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
444{
445    return NS_ERROR_NOT_IMPLEMENTED;
446}
447
448/* End of implementation class template. */
449#endif
450
451
452#endif /* __gen_nsIChannel_h__ */