The Tor Browser: comparison netwerk/protocol/http/Http2Stream.h

--1:000000000000
+:e7daf9f48c62
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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_Http2Stream_h
+#define mozilla_net_Http2Stream_h
+#include "mozilla/Attributes.h"
+#include "nsAHttpTransaction.h"
+#include "nsISupportsPriority.h"
+namespace mozilla {
+namespace net {
+class Http2Session;
+class Http2Decompressor;
+class Http2Stream
+: public nsAHttpSegmentReader
+, public nsAHttpSegmentWriter
+{
+public:
+NS_DECL_NSAHTTPSEGMENTREADER
+NS_DECL_NSAHTTPSEGMENTWRITER
+enum stateType {
+IDLE,
+RESERVED_BY_REMOTE,
+OPEN,
+CLOSED_BY_LOCAL,
+CLOSED_BY_REMOTE,
+CLOSED
+};
+const static int32_t kNormalPriority = 0x1000;
+const static int32_t kWorstPriority = kNormalPriority + nsISupportsPriority::PRIORITY_LOWEST;
+const static int32_t kBestPriority = kNormalPriority + nsISupportsPriority::PRIORITY_HIGHEST;
+Http2Stream(nsAHttpTransaction *, Http2Session *, int32_t);
+uint32_t StreamID() { return mStreamID; }
+Http2PushedStream *PushSource() { return mPushSource; }
+stateType HTTPState() { return mState; }
+void SetHTTPState(stateType val) { mState = val; }
+virtual nsresult ReadSegments(nsAHttpSegmentReader *,  uint32_t, uint32_t *);
+virtual nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *);
+virtual bool DeferCleanupOnSuccess() { return false; }
+const nsAFlatCString &Origin() const { return mOrigin; }
+bool RequestBlockedOnRead()
+{
+return static_cast<bool>(mRequestBlockedOnRead);
+}
+bool HasRegisteredID() { return mStreamID != 0; }
+nsAHttpTransaction *Transaction() { return mTransaction; }
+virtual nsILoadGroupConnectionInfo *LoadGroupConnectionInfo()
+{
+return mTransaction ? mTransaction->LoadGroupConnectionInfo() : nullptr;
+}
+void Close(nsresult reason);
+void SetRecvdFin(bool aStatus);
+bool RecvdFin() { return mRecvdFin; }
+void SetSentFin(bool aStatus);
+bool SentFin() { return mSentFin; }
+void SetRecvdReset(bool aStatus);
+bool RecvdReset() { return mRecvdReset; }
+void SetSentReset(bool aStatus);
+bool SentReset() { return mSentReset; }
+void SetCountAsActive(bool aStatus) { mCountAsActive = aStatus ? 1 : 0; }
+bool CountAsActive() { return mCountAsActive; }
+void SetAllHeadersReceived(bool aStatus) { mAllHeadersReceived = aStatus ? 1 : 0; }
+bool AllHeadersReceived() { return mAllHeadersReceived; }
+void UpdateTransportSendEvents(uint32_t count);
+void UpdateTransportReadEvents(uint32_t count);
+nsresult ConvertResponseHeaders(Http2Decompressor *, nsACString &, nsACString &);
+nsresult ConvertPushHeaders(Http2Decompressor *, nsACString &, nsACString &);
+bool AllowFlowControlledWrite();
+void UpdateServerReceiveWindow(int32_t delta);
+int64_t ServerReceiveWindow() { return mServerReceiveWindow; }
+void DecrementClientReceiveWindow(uint32_t delta) {
+mClientReceiveWindow -= delta;
+mLocalUnacked += delta;
+}
+void IncrementClientReceiveWindow(uint32_t delta) {
+mClientReceiveWindow += delta;
+mLocalUnacked -= delta;
+}
+uint64_t LocalUnAcked() { return mLocalUnacked; }
+int64_t  ClientReceiveWindow()  { return mClientReceiveWindow; }
+bool     BlockedOnRwin() { return mBlockedOnRwin; }
+uint32_t Priority() { return mPriority; }
+void SetPriority(uint32_t);
+// A pull stream has an implicit sink, a pushed stream has a sink
+// once it is matched to a pull stream.
+virtual bool HasSink() { return true; }
+virtual ~Http2Stream();
+protected:
+static void CreatePushHashKey(const nsCString &scheme,
+const nsCString &hostHeader,
+uint64_t serial,
+const nsCSubstring &pathInfo,
+nsCString &outOrigin,
+nsCString &outKey);
+// These internal states track request generation
+enum upstreamStateType {
+GENERATING_HEADERS,
+GENERATING_BODY,
+SENDING_BODY,
+SENDING_FIN_STREAM,
+UPSTREAM_COMPLETE
+};
+uint32_t mStreamID;
+// The session that this stream is a subset of
+Http2Session *mSession;
+nsCString     mOrigin;
+nsCString     mHeaderHost;
+nsCString     mHeaderScheme;
+nsCString     mHeaderPath;
+// Each stream goes from generating_headers to upstream_complete, perhaps
+// looping on multiple instances of generating_body and
+// sending_body for each frame in the upload.
+enum upstreamStateType mUpstreamState;
+// The HTTP/2 state for the stream from section 5.1
+enum stateType mState;
+// Flag is set when all http request headers have been read and ID is stable
+uint32_t                     mAllHeadersSent       : 1;
+// Flag is set when all http request headers have been read and ID is stable
+uint32_t                     mAllHeadersReceived   : 1;
+void     ChangeState(enum upstreamStateType);
+private:
+friend class nsAutoPtr<Http2Stream>;
+nsresult ParseHttpRequestHeaders(const char *, uint32_t, uint32_t *);
+void     AdjustPushedPriority();
+void     AdjustInitialWindow();
+nsresult TransmitFrame(const char *, uint32_t *, bool forceCommitment);
+void     GenerateDataFrameHeader(uint32_t, bool);
+// The underlying HTTP transaction. This pointer is used as the key
+// in the Http2Session mStreamTransactionHash so it is important to
+// keep a reference to it as long as this stream is a member of that hash.
+// (i.e. don't change it or release it after it is set in the ctor).
+nsRefPtr<nsAHttpTransaction> mTransaction;
+// The underlying socket transport object is needed to propogate some events
+nsISocketTransport         *mSocketTransport;
+// These are temporary state variables to hold the argument to
+// Read/WriteSegments so it can be accessed by On(read/write)segment
+// further up the stack.
+nsAHttpSegmentReader        *mSegmentReader;
+nsAHttpSegmentWriter        *mSegmentWriter;
+// The quanta upstream data frames are chopped into
+uint32_t                    mChunkSize;
+// Flag is set when the HTTP processor has more data to send
+// but has blocked in doing so.
+uint32_t                     mRequestBlockedOnRead : 1;
+// Flag is set after the response frame bearing the fin bit has
+// been processed. (i.e. after the server has closed).
+uint32_t                     mRecvdFin             : 1;
+// Flag is set after RST_STREAM has been received for this stream
+uint32_t                     mRecvdReset           : 1;
+// Flag is set after RST_STREAM has been generated for this stream
+uint32_t                     mSentReset            : 1;
+// Flag is set when stream is counted towards MAX_CONCURRENT streams in session
+uint32_t                     mCountAsActive        : 1;
+// Flag is set when a FIN has been placed on a data or header frame
+// (i.e after the client has closed)
+uint32_t                     mSentFin              : 1;
+// Flag is set after the WAITING_FOR Transport event has been generated
+uint32_t                     mSentWaitingFor       : 1;
+// Flag is set after TCP send autotuning has been disabled
+uint32_t                     mSetTCPSocketBuffer   : 1;
+// The InlineFrame and associated data is used for composing control
+// frames and data frame headers.
+nsAutoArrayPtr<uint8_t>      mTxInlineFrame;
+uint32_t                     mTxInlineFrameSize;
+uint32_t                     mTxInlineFrameUsed;
+// mTxStreamFrameSize tracks the progress of
+// transmitting a request body data frame. The data frame itself
+// is never copied into the spdy layer.
+uint32_t                     mTxStreamFrameSize;
+// Buffer for request header compression.
+nsCString                    mFlatHttpRequestHeaders;
+// Track the content-length of a request body so that we can
+// place the fin flag on the last data packet instead of waiting
+// for a stream closed indication. Relying on stream close results
+// in an extra 0-length runt packet and seems to have some interop
+// problems with the google servers.
+int64_t                      mRequestBodyLenRemaining;
+// 0 is highest.. up to 2^31 - 1 as lowest
+uint32_t                     mPriority;
+// mClientReceiveWindow, mServerReceiveWindow, and mLocalUnacked are for flow control.
+// *window are signed because the race conditions in asynchronous SETTINGS
+// messages can force them temporarily negative.
+// mClientReceiveWindow is how much data the server will send without getting a
+//   window update
+int64_t                      mClientReceiveWindow;
+// mServerReceiveWindow is how much data the client is allowed to send without
+//   getting a window update
+int64_t                      mServerReceiveWindow;
+// LocalUnacked is the number of bytes received by the client but not
+//   yet reflected in a window update. Sending that update will increment
+//   ClientReceiveWindow
+uint64_t                     mLocalUnacked;
+// True when sending is suspended becuase the server receive window is
+//   <= 0
+bool                         mBlockedOnRwin;
+// For Progress Events
+uint64_t                     mTotalSent;
+uint64_t                     mTotalRead;
+// For Http2Push
+Http2PushedStream *mPushSource;
+};
+} // namespace mozilla::net
+} // namespace mozilla
+#endif // mozilla_net_Http2Stream_h

The Tor Browser / file comparison

comparison: netwerk/protocol/http/Http2Stream.h

netwerk/protocol/http/Http2Stream.h