PageRenderTime 60ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 1ms

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