Http2StreamTunnel.h

Enable keyboard shortcuts

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set sw=2 ts=8 et tw=80 : */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_net_Http2StreamTunnel_h

#define mozilla_net_Http2StreamTunnel_h

#include "Http2StreamBase.h"

#include "nsHttpConnection.h"

#include "nsWeakReference.h"

namespace mozilla::net {

class OutputStreamTunnel;

class InputStreamTunnel;

// c881f764-a183-45cb-9dec-d9872b2f47b2

#define NS_HTTP2STREAMTUNNEL_IID                     \

  {                                                  \

    0xc881f764, 0xa183, 0x45cb, {                    \

      0x9d, 0xec, 0xd9, 0x87, 0x2b, 0x2f, 0x47, 0xb2 \

    }                                                \

class Http2StreamTunnel : public Http2StreamBase,

                          public nsISocketTransport,

                          public nsSupportsWeakReference {

 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_HTTP2STREAMTUNNEL_IID)

  NS_DECL_THREADSAFE_ISUPPORTS

  NS_DECL_NSITRANSPORT

  NS_DECL_NSISOCKETTRANSPORT

  Http2StreamTunnel(Http2Session* session, int32_t priority, uint64_t bcId,

                    nsHttpConnectionInfo* aConnectionInfo);

  bool IsTunnel() override { return true; }

  already_AddRefed<nsHttpConnection> CreateHttpConnection(

      nsAHttpTransaction* httpTransaction, nsIInterfaceRequestor* aCallbacks,

      PRIntervalTime aRtt, bool aIsWebSocket);

  nsHttpConnectionInfo* ConnectionInfo() override { return mConnectionInfo; }

  void SetRequestDone() { mSendClosed = true; }

  nsresult Condition() override { return mCondition; }

  void CloseStream(nsresult reason) override;

  void DisableSpdy() override {

    if (mTransaction) {

      mTransaction->DisableHttp2ForProxy();

  void ReuseConnectionOnRestartOK(bool aReuse) override {

    // Do nothing here. We'll never reuse the connection.

  void MakeNonSticky() override {}

 protected:

  ~Http2StreamTunnel();

  nsresult CallToReadData(uint32_t count, uint32_t* countRead) override;

  nsresult CallToWriteData(uint32_t count, uint32_t* countWritten) override;

  void HandleResponseHeaders(nsACString& aHeadersOut,

                             int32_t httpResponseCode) override;

  nsresult GenerateHeaders(nsCString& aCompressedData,

                           uint8_t& firstFrameFlags) override;

  bool CloseSendStreamWhenDone() override { return mSendClosed; }

  RefPtr<nsAHttpTransaction> mTransaction;

  void ClearTransactionsBlockedOnTunnel();

  bool DispatchRelease();

  RefPtr<OutputStreamTunnel> mOutput;

  RefPtr<InputStreamTunnel> mInput;

  RefPtr<nsHttpConnectionInfo> mConnectionInfo;

  bool mSendClosed{false};

  nsresult mCondition{NS_OK};

};

// f9d10060-f5d4-443e-ba59-f84ea975c5f0

#define NS_OUTPUTSTREAMTUNNEL_IID                    \

  {                                                  \

    0xf9d10060, 0xf5d4, 0x443e, {                    \

      0xba, 0x59, 0xf8, 0x4e, 0xa9, 0x75, 0xc5, 0xf0 \

    }                                                \

class OutputStreamTunnel : public nsIAsyncOutputStream {

 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_OUTPUTSTREAMTUNNEL_IID)

  NS_DECL_THREADSAFE_ISUPPORTS

  NS_DECL_NSIOUTPUTSTREAM

  NS_DECL_NSIASYNCOUTPUTSTREAM

  explicit OutputStreamTunnel(Http2StreamTunnel* aStream);

  nsresult OnSocketReady(nsresult condition);

  void MaybeSetRequestDone(nsIOutputStreamCallback* aCallback);

 private:

  virtual ~OutputStreamTunnel();

  nsresult GetStream(Http2StreamTunnel** aStream);

  nsresult GetSession(Http2Session** aSession);

  nsWeakPtr mWeakStream;

  nsCOMPtr<nsIOutputStreamCallback> mCallback;

  nsresult mCondition{NS_OK};

};

class InputStreamTunnel : public nsIAsyncInputStream {

 public:

  NS_DECL_THREADSAFE_ISUPPORTS

  NS_DECL_NSIINPUTSTREAM

  NS_DECL_NSIASYNCINPUTSTREAM

  explicit InputStreamTunnel(Http2StreamTunnel* aStream);

  nsresult OnSocketReady(nsresult condition);

  bool HasCallback() { return !!mCallback; }

 private:

  virtual ~InputStreamTunnel();

  nsresult GetStream(Http2StreamTunnel** aStream);

  nsresult GetSession(Http2Session** aSession);

  nsWeakPtr mWeakStream;

  nsCOMPtr<nsIInputStreamCallback> mCallback;

  nsresult mCondition{NS_OK};

};

NS_DEFINE_STATIC_IID_ACCESSOR(Http2StreamTunnel, NS_HTTP2STREAMTUNNEL_IID)

NS_DEFINE_STATIC_IID_ACCESSOR(OutputStreamTunnel, NS_OUTPUTSTREAMTUNNEL_IID)

class Http2StreamWebSocket : public Http2StreamTunnel {

 public:

  Http2StreamWebSocket(Http2Session* session, int32_t priority, uint64_t bcId,

                       nsHttpConnectionInfo* aConnectionInfo);

  void CloseStream(nsresult reason) override;

 protected:

  virtual ~Http2StreamWebSocket();

  nsresult GenerateHeaders(nsCString& aCompressedData,

                           uint8_t& firstFrameFlags) override;

};

}  // namespace mozilla::net

#endif  // mozilla_net_Http2StreamTunnel_h