Bug 1452600 Comment 97 Edit History

Note: The actual edited comment in the bug view page will always show the original commenter’s name and original timestamp.

Original comment by
on 
I think you can create an class such as:
```
class PumpListenerProxy final : nsIStreamListner {
 public:
  NS_DECL_ISUPPORTS

  PumpListenerProxy(nsIStreamListener* aListener, nsIChannel* aChannel)
      : mListener(aListener), mChannel(aChannel) {
    MOZ_ASSERT(aListener);
    MOZ_ASSERT(aChannel);
  }

  NS_IMETHOD
  OnDataAvailable(nsIRequest* aRequest, nsISupports* aContext,
                  nsIInputStream* aIStream, uint64_t aSourceOffset,
                  uint32_t aLength) override {
    // Proxy OnDataAvailable using the internal channel
    return mListener->OnDataAvailable(mChannel, aContext, aIStream,
                                      aSourceOffset, aLength);
  }

  NS_IMETHOD
  OnStartRequest(nsIRequest* aRequest, nsISupports* aContext) override {
    // Proxy OnStartRequest using the internal channel
    return mListener->OnStartRequest(mChannel, aContext);
  }

  NS_IMETHOD
  OnStopRequest(nsIRequest* aRequest, nsISupports* aContext,
                nsresult aStatusCode) override {
    // Proxy OnStopRequest using the inernal channel
    return mListener->OnStopRequest(mChannel, aContext, aStatusCode);
  }

 private:
  ~PluginContextProxy() {}
  nsCOMPtr<nsIChannel> mChannel;
};
```
And use it such as:
```
- rv = pump->AsyncRead(this, urlSupports);
+ RefPtr<PumpListenerProxy> proxy = new PumpListenerProxy(this, this);
+ rv = pump->AsyncRead(proxy, urlSupports);
```
(Borrowed an idea from Chris, see comment #7)
Revision 1 by
on 
I think you can create an class such as:
```
class PumpListenerProxy final : public nsIStreamListner {
 public:
  NS_DECL_ISUPPORTS

  PumpListenerProxy(nsIStreamListener* aListener, nsIChannel* aChannel)
      : mListener(aListener), mChannel(aChannel) {
    MOZ_ASSERT(aListener);
    MOZ_ASSERT(aChannel);
  }

  NS_IMETHOD
  OnDataAvailable(nsIRequest* aRequest, nsISupports* aContext,
                  nsIInputStream* aIStream, uint64_t aSourceOffset,
                  uint32_t aLength) override {
    // Proxy OnDataAvailable using the internal channel
    return mListener->OnDataAvailable(mChannel, aContext, aIStream,
                                      aSourceOffset, aLength);
  }

  NS_IMETHOD
  OnStartRequest(nsIRequest* aRequest, nsISupports* aContext) override {
    // Proxy OnStartRequest using the internal channel
    return mListener->OnStartRequest(mChannel, aContext);
  }

  NS_IMETHOD
  OnStopRequest(nsIRequest* aRequest, nsISupports* aContext,
                nsresult aStatusCode) override {
    // Proxy OnStopRequest using the inernal channel
    return mListener->OnStopRequest(mChannel, aContext, aStatusCode);
  }

 private:
  ~PluginContextProxy() {}
  nsCOMPtr<nsIChannel> mChannel;
};
```
And use it such as:
```
- rv = pump->AsyncRead(this, urlSupports);
+ RefPtr<PumpListenerProxy> proxy = new PumpListenerProxy(this, this);
+ rv = pump->AsyncRead(proxy, urlSupports);
```
(Borrowed an idea from Chris, see comment #7)
Revision 2 by
on 
I think you can create an class such as:
```
class PumpListenerProxy final : public nsIStreamListner {
 public:
  NS_DECL_ISUPPORTS

  PumpListenerProxy(nsIStreamListener* aListener, nsIChannel* aChannel)
      : mListener(aListener), mChannel(aChannel) {
    MOZ_ASSERT(aListener);
    MOZ_ASSERT(aChannel);
  }

  NS_IMETHOD
  OnDataAvailable(nsIRequest* aRequest, nsISupports* aContext,
                  nsIInputStream* aIStream, uint64_t aSourceOffset,
                  uint32_t aLength) override {
    // Proxy OnDataAvailable using the internal channel
    return mListener->OnDataAvailable(mChannel, aContext, aIStream,
                                      aSourceOffset, aLength);
  }

  NS_IMETHOD
  OnStartRequest(nsIRequest* aRequest, nsISupports* aContext) override {
    // Proxy OnStartRequest using the internal channel
    return mListener->OnStartRequest(mChannel, aContext);
  }

  NS_IMETHOD
  OnStopRequest(nsIRequest* aRequest, nsISupports* aContext,
                nsresult aStatusCode) override {
    // Proxy OnStopRequest using the inernal channel
    return mListener->OnStopRequest(mChannel, aContext, aStatusCode);
  }

 private:
  ~PumpListenerProxy() {}
  nsCOMPtr<nsIChannel> mChannel;
};
```
And use it such as:
```
- rv = pump->AsyncRead(this, urlSupports);
+ RefPtr<PumpListenerProxy> proxy = new PumpListenerProxy(this, this);
+ rv = pump->AsyncRead(proxy, urlSupports);
```
(Borrowed an idea from Chris, see comment #7)
Revision 3 by
on 
I think you can create an class such as:
```
class PumpListenerProxy final : public nsIStreamListner {
 public:
  NS_DECL_ISUPPORTS

  PumpListenerProxy(nsIStreamListener* aListener, nsIChannel* aChannel)
      : mListener(aListener), mChannel(aChannel) {
    MOZ_ASSERT(aListener);
    MOZ_ASSERT(aChannel);
  }

  NS_IMETHOD
  OnDataAvailable(nsIRequest* aRequest, nsISupports* aContext,
                  nsIInputStream* aIStream, uint64_t aSourceOffset,
                  uint32_t aLength) override {
    // Proxy OnDataAvailable using the internal channel
    return mListener->OnDataAvailable(mChannel, aContext, aIStream,
                                      aSourceOffset, aLength);
  }

  NS_IMETHOD
  OnStartRequest(nsIRequest* aRequest, nsISupports* aContext) override {
    // Proxy OnStartRequest using the internal channel
    return mListener->OnStartRequest(mChannel, aContext);
  }

  NS_IMETHOD
  OnStopRequest(nsIRequest* aRequest, nsISupports* aContext,
                nsresult aStatusCode) override {
    // Proxy OnStopRequest using the inernal channel
    return mListener->OnStopRequest(mChannel, aContext, aStatusCode);
  }

 private:
  ~PumpListenerProxy() {}
  nsCOMPtr<nsIStreamListener> mListener;
  nsCOMPtr<nsIChannel> mChannel;
};
```
And use it such as:
```
- rv = pump->AsyncRead(this, urlSupports);
+ RefPtr<PumpListenerProxy> proxy = new PumpListenerProxy(this, this);
+ rv = pump->AsyncRead(proxy, urlSupports);
```
(Borrowed an idea from Chris, see comment #7)
Revision 4 by
on 
I think you can create a class such as:
```
class PumpListenerProxy final : public nsIStreamListner {
 public:
  NS_DECL_ISUPPORTS

  PumpListenerProxy(nsIStreamListener* aListener, nsIChannel* aChannel)
      : mListener(aListener), mChannel(aChannel) {
    MOZ_ASSERT(aListener);
    MOZ_ASSERT(aChannel);
  }

  NS_IMETHOD
  OnDataAvailable(nsIRequest* aRequest, nsISupports* aContext,
                  nsIInputStream* aIStream, uint64_t aSourceOffset,
                  uint32_t aLength) override {
    // Proxy OnDataAvailable using the internal channel
    return mListener->OnDataAvailable(mChannel, aContext, aIStream,
                                      aSourceOffset, aLength);
  }

  NS_IMETHOD
  OnStartRequest(nsIRequest* aRequest, nsISupports* aContext) override {
    // Proxy OnStartRequest using the internal channel
    return mListener->OnStartRequest(mChannel, aContext);
  }

  NS_IMETHOD
  OnStopRequest(nsIRequest* aRequest, nsISupports* aContext,
                nsresult aStatusCode) override {
    // Proxy OnStopRequest using the inernal channel
    return mListener->OnStopRequest(mChannel, aContext, aStatusCode);
  }

 private:
  ~PumpListenerProxy() {}
  nsCOMPtr<nsIStreamListener> mListener;
  nsCOMPtr<nsIChannel> mChannel;
};
```
And use it such as:
```
- rv = pump->AsyncRead(this, urlSupports);
+ RefPtr<PumpListenerProxy> proxy = new PumpListenerProxy(this, this);
+ rv = pump->AsyncRead(proxy, urlSupports);
```
(Borrowed an idea from Chris, see comment #7)

Back to Bug 1452600 Comment 97