/* -*- 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/. */

// HttpLog.h should generally be included first

#include "HttpLog.h"

// Log on level :5, instead of default :4.

#undef LOG

#define LOG(args) LOG5(args)

#undef LOG_ENABLED

#define LOG_ENABLED() LOG5_ENABLED()

#include <algorithm>

#include "Http2Compression.h"

#include "Http2Session.h"

#include "Http2Stream.h"

#include "Http2Push.h"

#include "TunnelUtils.h"

#include "mozilla/BasePrincipal.h"

#include "mozilla/Telemetry.h"

#include "nsAlgorithm.h"

#include "nsHttp.h"

#include "nsHttpHandler.h"

#include "nsHttpRequestHead.h"

#include "nsIClassOfService.h"

#include "nsIPipe.h"

#include "nsISocketTransport.h"

#include "nsStandardURL.h"

#include "prnetdb.h"

namespace mozilla {

namespace net {

Http2Stream::Http2Stream(nsAHttpTransaction *httpTransaction,

                         Http2Session *session,

                         int32_t priority,

                         uint64_t windowId)

  : mStreamID(0)

  , mSession(session)

  , mSegmentReader(nullptr)

  , mSegmentWriter(nullptr)

  , mUpstreamState(GENERATING_HEADERS)

  , mState(IDLE)

  , mRequestHeadersDone(0)

  , mOpenGenerated(0)

  , mAllHeadersReceived(0)

  , mQueued(0)

  , mSocketTransport(session->SocketTransport())

  , mTransaction(httpTransaction)

  , mChunkSize(session->SendingChunkSize())

  , mRequestBlockedOnRead(0)

  , mRecvdFin(0)

  , mReceivedData(0)

  , mRecvdReset(0)

  , mSentReset(0)

  , mCountAsActive(0)

  , mSentFin(0)

  , mSentWaitingFor(0)

  , mSetTCPSocketBuffer(0)

  , mBypassInputBuffer(0)

  , mTxInlineFrameSize(Http2Session::kDefaultBufferSize)

  , mTxInlineFrameUsed(0)

  , mTxStreamFrameSize(0)

  , mRequestBodyLenRemaining(0)

  , mLocalUnacked(0)

  , mBlockedOnRwin(false)

  , mTotalSent(0)

  , mTotalRead(0)

  , mPushSource(nullptr)

  , mAttempting0RTT(false)

  , mCurrentForegroundTabOuterContentWindowId(windowId)

  , mTransactionTabId(0)

  , mIsTunnel(false)

  , mPlainTextTunnel(false)

{

  MOZ_ASSERT(OnSocketThread(), "not on socket thread");

  nsHttpTransaction *trans = mTransaction->QueryHttpTransaction();

  LOG3(("Http2Stream::Http2Stream %p trans=%p atrans=%p", this, trans, httpTransaction));

  mServerReceiveWindow = session->GetServerInitialStreamWindow();

  mClientReceiveWindow = session->PushAllowance();

  mTxInlineFrame = MakeUnique<uint8_t[]>(mTxInlineFrameSize);

  static_assert(nsISupportsPriority::PRIORITY_LOWEST <= kNormalPriority,

                "Lowest Priority should be less than kNormalPriority");

  // values of priority closer to 0 are higher priority for the priority

  // argument. This value is used as a group, which maps to a

  // weight that is related to the nsISupportsPriority that we are given.

  int32_t httpPriority;

  if (priority >= nsISupportsPriority::PRIORITY_LOWEST) {

    httpPriority = kWorstPriority;

  } else if (priority <= nsISupportsPriority::PRIORITY_HIGHEST) {

    httpPriority = kBestPriority;

  } else {

    httpPriority = kNormalPriority + priority;

  }

  MOZ_ASSERT(httpPriority >= 0);

  SetPriority(static_cast<uint32_t>(httpPriority));

  if (trans) {

    mTransactionTabId = trans->TopLevelOuterContentWindowId();

  }

}

Http2Stream::~Http2Stream()

{

  ClearPushSource();

  ClearTransactionsBlockedOnTunnel();

  mStreamID = Http2Session::kDeadStreamID;

  LOG3(("Http2Stream::~Http2Stream %p", this));

}

void

Http2Stream::ClearPushSource()

{

  if (mPushSource) {

    mPushSource->SetConsumerStream(nullptr);

    mPushSource = nullptr;

  }

}

// ReadSegments() is used to write data down the socket. Generally, HTTP

// request data is pulled from the approriate transaction and

// converted to HTTP/2 data. Sometimes control data like a window-update is

// generated instead.

nsresult

Http2Stream::ReadSegments(nsAHttpSegmentReader *reader,

                          uint32_t count,

                          uint32_t *countRead)

{

  LOG3(("Http2Stream %p ReadSegments reader=%p count=%d state=%x",

        this, reader, count, mUpstreamState));

  MOZ_ASSERT(OnSocketThread(), "not on socket thread");

  nsresult rv = NS_ERROR_UNEXPECTED;

  mRequestBlockedOnRead = 0;

  if (mRecvdFin || mRecvdReset) {

    // Don't transmit any request frames if the peer cannot respond

    LOG3(("Http2Stream %p ReadSegments request stream aborted due to"

          " response side closure\n", this));

    return NS_ERROR_ABORT;

  }

  // avoid runt chunks if possible by anticipating

  // full data frames

  if (count > (mChunkSize + 8)) {

    uint32_t numchunks = count / (mChunkSize + 8);

    count = numchunks * (mChunkSize + 8);

  }

  switch (mUpstreamState) {

  case GENERATING_HEADERS:

  case GENERATING_BODY:

  case SENDING_BODY:

    // Call into the HTTP Transaction to generate the HTTP request

    // stream. That stream will show up in OnReadSegment().

    mSegmentReader = reader;

    rv = mTransaction->ReadSegments(this, count, countRead);

    mSegmentReader = nullptr;

    LOG3(("Http2Stream::ReadSegments %p trans readsegments rv %" PRIx32 " read=%d\n",

          this, static_cast<uint32_t>(rv), *countRead));

    // Check to see if the transaction's request could be written out now.

    // If not, mark the stream for callback when writing can proceed.

    if (NS_SUCCEEDED(rv) &&

        mUpstreamState == GENERATING_HEADERS &&

        !mRequestHeadersDone)

      mSession->TransactionHasDataToWrite(this);

    // mTxinlineFrameUsed represents any queued un-sent frame. It might

    // be 0 if there is no such frame, which is not a gurantee that we

    // don't have more request body to send - just that any data that was

    // sent comprised a complete HTTP/2 frame. Likewise, a non 0 value is

    // a queued, but complete, http/2 frame length.

    // Mark that we are blocked on read if the http transaction needs to

    // provide more of the request message body and there is nothing queued

    // for writing

    if (rv == NS_BASE_STREAM_WOULD_BLOCK && !mTxInlineFrameUsed)

      mRequestBlockedOnRead = 1;

    // A transaction that had already generated its headers before it was

    // queued at the session level (due to concurrency concerns) may not call

    // onReadSegment off the ReadSegments() stack above.

    if (mUpstreamState == GENERATING_HEADERS && NS_SUCCEEDED(rv)) {

      LOG3(("Http2Stream %p ReadSegments forcing OnReadSegment call\n", this));

      uint32_t wasted = 0;

      mSegmentReader = reader;

      Unused << OnReadSegment("", 0, &wasted);

      mSegmentReader = nullptr;

    }

    // If the sending flow control window is open (!mBlockedOnRwin) then

    // continue sending the request

    if (!mBlockedOnRwin && mOpenGenerated &&

        !mTxInlineFrameUsed && NS_SUCCEEDED(rv) && (!*countRead)) {

      MOZ_ASSERT(!mQueued);

      MOZ_ASSERT(mRequestHeadersDone);

      LOG3(("Http2Stream::ReadSegments %p 0x%X: Sending request data complete, "

            "mUpstreamState=%x\n",this, mStreamID, mUpstreamState));

      if (mSentFin) {

        ChangeState(UPSTREAM_COMPLETE);

      } else {

        GenerateDataFrameHeader(0, true);

        ChangeState(SENDING_FIN_STREAM);

        mSession->TransactionHasDataToWrite(this);

        rv = NS_BASE_STREAM_WOULD_BLOCK;

      }

    }

    break;

  case SENDING_FIN_STREAM:

    // We were trying to send the FIN-STREAM but were blocked from

    // sending it out - try again.

    if (!mSentFin) {

      mSegmentReader = reader;

      rv = TransmitFrame(nullptr, nullptr, false);

      mSegmentReader = nullptr;

      MOZ_ASSERT(NS_FAILED(rv) || !mTxInlineFrameUsed,

                 "Transmit Frame should be all or nothing");

      if (NS_SUCCEEDED(rv))

        ChangeState(UPSTREAM_COMPLETE);

    } else {

      rv = NS_OK;

      mTxInlineFrameUsed = 0;         // cancel fin data packet

      ChangeState(UPSTREAM_COMPLETE);

    }

    *countRead = 0;

    // don't change OK to WOULD BLOCK. we are really done sending if OK

    break;

  case UPSTREAM_COMPLETE:

    *countRead = 0;

    rv = NS_OK;

    break;

  default:

    MOZ_ASSERT(false, "Http2Stream::ReadSegments unknown state");

    break;

  }

  return rv;

}

uint64_t

Http2Stream::LocalUnAcked()

{

  // reduce unacked by the amount of undelivered data

  // to help assert flow control

  uint64_t undelivered = mSimpleBuffer.Available();

  if (undelivered > mLocalUnacked) {

    return 0;

  }

  return mLocalUnacked - undelivered;

}

nsresult

Http2Stream::BufferInput(uint32_t count, uint32_t *countWritten)

{

  char buf[SimpleBufferPage::kSimpleBufferPageSize];

  if (SimpleBufferPage::kSimpleBufferPageSize < count) {

    count = SimpleBufferPage::kSimpleBufferPageSize;

  }

  mBypassInputBuffer = 1;

  nsresult rv = mSegmentWriter->OnWriteSegment(buf, count, countWritten);

  mBypassInputBuffer = 0;

  if (NS_SUCCEEDED(rv)) {

    rv = mSimpleBuffer.Write(buf, *countWritten);

    if (NS_FAILED(rv)) {

      MOZ_ASSERT(rv == NS_ERROR_OUT_OF_MEMORY);

      return NS_ERROR_OUT_OF_MEMORY;

    }

  }

  return rv;

}

bool

Http2Stream::DeferCleanup(nsresult status)

{

  // do not cleanup a stream that has data buffered for the transaction

  return (NS_SUCCEEDED(status) && mSimpleBuffer.Available());

}

// WriteSegments() is used to read data off the socket. Generally this is

// just a call through to the associated nsHttpTransaction for this stream

// for the remaining data bytes indicated by the current DATA frame.

nsresult

Http2Stream::WriteSegments(nsAHttpSegmentWriter *writer,

                           uint32_t count,

                           uint32_t *countWritten)

{

  MOZ_ASSERT(OnSocketThread(), "not on socket thread");

  MOZ_ASSERT(!mSegmentWriter, "segment writer in progress");

  LOG3(("Http2Stream::WriteSegments %p count=%d state=%x",

        this, count, mUpstreamState));

  mSegmentWriter = writer;

  nsresult rv = mTransaction->WriteSegments(this, count, countWritten);

  if (rv == NS_BASE_STREAM_WOULD_BLOCK) {

    // consuming transaction won't take data. but we need to read it into a buffer so that it

    // won't block other streams. but we should not advance the flow control window

    // so that we'll eventually push back on the sender.

    // with tunnels you need to make sure that this is an underlying connction established

    // that can be meaningfully giving this signal

    bool doBuffer = true;

    if (mIsTunnel) {

      RefPtr<SpdyConnectTransaction> qiTrans(mTransaction->QuerySpdyConnectTransaction());

      if (qiTrans) {

        doBuffer = qiTrans->ConnectedReadyForInput();

      }

    }

    // stash this data

    if (doBuffer) {

      rv = BufferInput(count, countWritten);

      LOG3(("Http2Stream::WriteSegments %p Buffered %" PRIX32 " %d\n", this,

            static_cast<uint32_t>(rv), *countWritten));

    }

  }

  mSegmentWriter = nullptr;

  return rv;

}

nsresult

Http2Stream::MakeOriginURL(const nsACString &origin, nsCOMPtr<nsIURI> &url)

{

  nsAutoCString scheme;

  nsresult rv = net_ExtractURLScheme(origin, scheme);

  NS_ENSURE_SUCCESS(rv, rv);

  return MakeOriginURL(scheme, origin, url);

}

nsresult

Http2Stream::MakeOriginURL(const nsACString &scheme, const nsACString &origin,

                           nsCOMPtr<nsIURI> &url)

{

  return NS_MutateURI(new nsStandardURL::Mutator())

    .Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init,

                            nsIStandardURL::URLTYPE_AUTHORITY,

                            scheme.EqualsLiteral("http") ? NS_HTTP_DEFAULT_PORT

                                                         : NS_HTTPS_DEFAULT_PORT,

                            nsCString(origin), nullptr, nullptr, nullptr))

    .Finalize(url);

}

void

Http2Stream::CreatePushHashKey(const nsCString &scheme,

                               const nsCString &hostHeader,

                               const mozilla::OriginAttributes &originAttributes,

                               uint64_t serial,

                               const nsACString& pathInfo,

                               nsCString &outOrigin,

                               nsCString &outKey)

{

  nsCString fullOrigin = scheme;

  fullOrigin.AppendLiteral("://");

  fullOrigin.Append(hostHeader);

  nsCOMPtr<nsIURI> origin;

  nsresult rv = Http2Stream::MakeOriginURL(scheme, fullOrigin, origin);

  if (NS_SUCCEEDED(rv)) {

    rv = origin->GetAsciiSpec(outOrigin);

    outOrigin.Trim("/", false, true, false);

  }

  if (NS_FAILED(rv)) {

    // Fallback to plain text copy - this may end up behaving poorly

    outOrigin = fullOrigin;

  }

  outKey = outOrigin;

  outKey.AppendLiteral("/[");

  nsAutoCString suffix;

  originAttributes.CreateSuffix(suffix);

  outKey.Append(suffix);

  outKey.Append(']');

  outKey.AppendLiteral("/[http2.");

  outKey.AppendInt(serial);

  outKey.Append(']');

  outKey.Append(pathInfo);

}

nsresult

Http2Stream::ParseHttpRequestHeaders(const char *buf,

                                     uint32_t avail,

                                     uint32_t *countUsed)

{

  // Returns NS_OK even if the headers are incomplete

  // set mRequestHeadersDone flag if they are complete

  MOZ_ASSERT(OnSocketThread(), "not on socket thread");

  MOZ_ASSERT(mUpstreamState == GENERATING_HEADERS);

  MOZ_ASSERT(!mRequestHeadersDone);

  LOG3(("Http2Stream::ParseHttpRequestHeaders %p avail=%d state=%x",

        this, avail, mUpstreamState));

  mFlatHttpRequestHeaders.Append(buf, avail);

  nsHttpRequestHead *head = mTransaction->RequestHead();

  // We can use the simple double crlf because firefox is the

  // only client we are parsing

  int32_t endHeader = mFlatHttpRequestHeaders.Find("\r\n\r\n");

  if (endHeader == kNotFound) {

    // We don't have all the headers yet

    LOG3(("Http2Stream::ParseHttpRequestHeaders %p "

          "Need more header bytes. Len = %d",

          this, mFlatHttpRequestHeaders.Length()));

    *countUsed = avail;

    return NS_OK;

  }

  // We have recvd all the headers, trim the local

  // buffer of the final empty line, and set countUsed to reflect

  // the whole header has been consumed.

  uint32_t oldLen = mFlatHttpRequestHeaders.Length();

  mFlatHttpRequestHeaders.SetLength(endHeader + 2);

  *countUsed = avail - (oldLen - endHeader) + 4;

  mRequestHeadersDone = 1;

  nsAutoCString authorityHeader;

  nsAutoCString hashkey;

  nsresult rv = head->GetHeader(nsHttp::Host, authorityHeader);

  if (NS_FAILED(rv)) {

    MOZ_ASSERT(false);

    return rv;

  }

  nsAutoCString requestURI;

  head->RequestURI(requestURI);

  mozilla::OriginAttributes originAttributes;

  mSocketTransport->GetOriginAttributes(&originAttributes);

  CreatePushHashKey(nsDependentCString(head->IsHTTPS() ? "https" : "http"),

                    authorityHeader, originAttributes, mSession->Serial(),

                    requestURI,

                    mOrigin, hashkey);

  // check the push cache for GET

  if (head->IsGet()) {

    // from :scheme, :authority, :path

    nsIRequestContext *requestContext = mTransaction->RequestContext();

    SpdyPushCache *cache = nullptr;

    if (requestContext) {

      requestContext->GetSpdyPushCache(&cache);

    }

    Http2PushedStream *pushedStream = nullptr;

    // If a push stream is attached to the transaction via onPush, match only with that

    // one. This occurs when a push was made with in conjunction with a nsIHttpPushListener

    nsHttpTransaction *trans = mTransaction->QueryHttpTransaction();

    if (trans && (pushedStream = trans->TakePushedStream())) {

      if (pushedStream->mSession == mSession) {

        LOG3(("Pushed Stream match based on OnPush correlation %p", pushedStream));

      } else {

        LOG3(("Pushed Stream match failed due to stream mismatch %p %" PRId64 " %" PRId64 "\n",

              pushedStream, pushedStream->mSession->Serial(), mSession->Serial()));

        pushedStream->OnPushFailed();

        pushedStream = nullptr;

      }

    }

    // we remove the pushedstream from the push cache so that

    // it will not be used for another GET. This does not destroy the

    // stream itself - that is done when the transactionhash is done with it.

    if (cache && !pushedStream){

        pushedStream = cache->RemovePushedStreamHttp2(hashkey);

    }

    LOG3(("Pushed Stream Lookup "

          "session=%p key=%s requestcontext=%p cache=%p hit=%p\n",

          mSession, hashkey.get(), requestContext, cache, pushedStream));

    if (pushedStream) {

      LOG3(("Pushed Stream Match located %p id=0x%X key=%s\n",

            pushedStream, pushedStream->StreamID(), hashkey.get()));

      pushedStream->SetConsumerStream(this);

      mPushSource = pushedStream;

      SetSentFin(true);

      AdjustPushedPriority();

      // There is probably pushed data buffered so trigger a read manually

      // as we can't rely on future network events to do it

      mSession->ConnectPushedStream(this);

      mOpenGenerated = 1;

      // if the "mother stream" had TRR, this one is a TRR stream too!

      RefPtr<nsHttpConnectionInfo> ci(Transaction()->ConnectionInfo());

      if (ci && ci->GetTrrUsed()) {

        mSession->IncrementTrrCounter();

      }

      return NS_OK;

    }

  }

  return NS_OK;

}

// This is really a headers frame, but open is pretty clear from a workflow pov

nsresult

Http2Stream::GenerateOpen()

{

  // It is now OK to assign a streamID that we are assured will

  // be monotonically increasing amongst new streams on this

  // session

  mStreamID = mSession->RegisterStreamID(this);

  MOZ_ASSERT(mStreamID & 1, "Http2 Stream Channel ID must be odd");

  MOZ_ASSERT(!mOpenGenerated);

  mOpenGenerated = 1;

  nsHttpRequestHead *head = mTransaction->RequestHead();

  nsAutoCString requestURI;

  head->RequestURI(requestURI);

  LOG3(("Http2Stream %p Stream ID 0x%X [session=%p] for URI %s\n",

        this, mStreamID, mSession, requestURI.get()));

  if (mStreamID >= 0x80000000) {

    // streamID must fit in 31 bits. Evading This is theoretically possible

    // because stream ID assignment is asynchronous to stream creation

    // because of the protocol requirement that the new stream ID

    // be monotonically increasing. In reality this is really not possible

    // because new streams stop being added to a session with millions of

    // IDs still available and no race condition is going to bridge that gap;

    // so we can be comfortable on just erroring out for correctness in that

    // case.

    LOG3(("Stream assigned out of range ID: 0x%X", mStreamID));

    return NS_ERROR_UNEXPECTED;

  }

  // Now we need to convert the flat http headers into a set

  // of HTTP/2 headers by writing to mTxInlineFrame{sz}

  nsCString compressedData;

  nsAutoCString authorityHeader;

  nsresult rv = head->GetHeader(nsHttp::Host, authorityHeader);

  if (NS_FAILED(rv)) {

    MOZ_ASSERT(false);

    return rv;

  }

  nsDependentCString scheme(head->IsHTTPS() ? "https" : "http");

  if (head->IsConnect()) {

    MOZ_ASSERT(mTransaction->QuerySpdyConnectTransaction());

    mIsTunnel = true;

    mRequestBodyLenRemaining = 0x0fffffffffffffffULL;

    // Our normal authority has an implicit port, best to use an

    // explicit one with a tunnel

    nsHttpConnectionInfo *ci = mTransaction->ConnectionInfo();

    if (!ci) {

      return NS_ERROR_UNEXPECTED;

    }

    authorityHeader = ci->GetOrigin();

    authorityHeader.Append(':');

    authorityHeader.AppendInt(ci->OriginPort());

  }

  nsAutoCString method;

  nsAutoCString path;

  head->Method(method);

  head->Path(path);

  rv = mSession->Compressor()->EncodeHeaderBlock(mFlatHttpRequestHeaders,

                                                 method,

                                                 path,

                                                 authorityHeader,

                                                 scheme,

                                                 head->IsConnect(),

                                                 compressedData);

  NS_ENSURE_SUCCESS(rv, rv);

  int64_t clVal = mSession->Compressor()->GetParsedContentLength();

  if (clVal != -1) {

    mRequestBodyLenRemaining = clVal;

  }

  // Determine whether to put the fin bit on the header frame or whether

  // to wait for a data packet to put it on.

  uint8_t firstFrameFlags =  Http2Session::kFlag_PRIORITY;

  if (head->IsGet() ||

      head->IsHead()) {

    // for GET and HEAD place the fin bit right on the

    // header packet

    SetSentFin(true);

    firstFrameFlags |= Http2Session::kFlag_END_STREAM;

  } else if (head->IsPost() ||

             head->IsPut() ||

             head->IsConnect()) {

    // place fin in a data frame even for 0 length messages for iterop

  } else if (!mRequestBodyLenRemaining) {

    // for other HTTP extension methods, rely on the content-length

    // to determine whether or not to put fin on headers

    SetSentFin(true);

    firstFrameFlags |= Http2Session::kFlag_END_STREAM;

  }

  // split this one HEADERS frame up into N HEADERS + CONTINUATION frames if it exceeds the

  // 2^14-1 limit for 1 frame. Do it by inserting header size gaps in the existing

  // frame for the new headers and for the first one a priority field. There is

  // no question this is ugly, but a 16KB HEADERS frame should be a long

  // tail event, so this is really just for correctness and a nop in the base case.

  //

  MOZ_ASSERT(!mTxInlineFrameUsed);

  uint32_t dataLength = compressedData.Length();

  uint32_t maxFrameData = Http2Session::kMaxFrameData - 5; // 5 bytes for priority

  uint32_t numFrames = 1;

  if (dataLength > maxFrameData) {

    numFrames += ((dataLength - maxFrameData) + Http2Session::kMaxFrameData - 1) /

      Http2Session::kMaxFrameData;

    MOZ_ASSERT (numFrames > 1);

  }

  // note that we could still have 1 frame for 0 bytes of data. that's ok.

  uint32_t messageSize = dataLength;

  messageSize += Http2Session::kFrameHeaderBytes + 5; // frame header + priority overhead in HEADERS frame

  messageSize += (numFrames - 1) * Http2Session::kFrameHeaderBytes; // frame header overhead in CONTINUATION frames

  EnsureBuffer(mTxInlineFrame, messageSize,

               mTxInlineFrameUsed, mTxInlineFrameSize);

  mTxInlineFrameUsed += messageSize;

  UpdatePriorityDependency();

  LOG3(("Http2Stream %p Generating %d bytes of HEADERS for stream 0x%X with "

        "priority weight %u dep 0x%X frames %u uri=%s\n",

        this, mTxInlineFrameUsed, mStreamID, mPriorityWeight,

        mPriorityDependency, numFrames, requestURI.get()));

  uint32_t outputOffset = 0;

  uint32_t compressedDataOffset = 0;

  for (uint32_t idx = 0; idx < numFrames; ++idx) {

    uint32_t flags, frameLen;

    bool lastFrame = (idx == numFrames - 1);

    flags = 0;

    frameLen = maxFrameData;

    if (!idx) {

      flags |= firstFrameFlags;

      // Only the first frame needs the 4-byte offset

      maxFrameData = Http2Session::kMaxFrameData;

    }

    if (lastFrame) {

      frameLen = dataLength;

      flags |= Http2Session::kFlag_END_HEADERS;

    }

    dataLength -= frameLen;

    mSession->CreateFrameHeader(

      mTxInlineFrame.get() + outputOffset,

      frameLen + (idx ? 0 : 5),

      (idx) ? Http2Session::FRAME_TYPE_CONTINUATION : Http2Session::FRAME_TYPE_HEADERS,

      flags, mStreamID);

    outputOffset += Http2Session::kFrameHeaderBytes;

    if (!idx) {

      uint32_t wireDep = PR_htonl(mPriorityDependency);

      memcpy(mTxInlineFrame.get() + outputOffset, &wireDep, 4);

      memcpy(mTxInlineFrame.get() + outputOffset + 4, &mPriorityWeight, 1);

      outputOffset += 5;

    }

    memcpy(mTxInlineFrame.get() + outputOffset,

           compressedData.BeginReading() + compressedDataOffset, frameLen);

    compressedDataOffset += frameLen;

    outputOffset += frameLen;

  }

  Telemetry::Accumulate(Telemetry::SPDY_SYN_SIZE, compressedData.Length());

  // The size of the input headers is approximate

  uint32_t ratio =

    compressedData.Length() * 100 /

    (11 + requestURI.Length() +

     mFlatHttpRequestHeaders.Length());

  mFlatHttpRequestHeaders.Truncate();

  Telemetry::Accumulate(Telemetry::SPDY_SYN_RATIO, ratio);

  return NS_OK;

}

void

Http2Stream::AdjustInitialWindow()

{

  // The default initial_window is sized for pushed streams. When we

  // generate a client pulled stream we want to disable flow control for

  // the stream with a window update. Do the same for pushed streams

  // when they connect to a pull.

  // >0 even numbered IDs are pushed streams.

  // odd numbered IDs are pulled streams.

  // 0 is the sink for a pushed stream.

  Http2Stream *stream = this;

  if (!mStreamID) {

    MOZ_ASSERT(mPushSource);

    if (!mPushSource)

      return;

    stream = mPushSource;

    MOZ_ASSERT(stream->mStreamID);

    MOZ_ASSERT(!(stream->mStreamID & 1)); // is a push stream

    // If the pushed stream has recvd a FIN, there is no reason to update

    // the window

    if (stream->RecvdFin() || stream->RecvdReset())

      return;

  }

  if (stream->mState == RESERVED_BY_REMOTE) {

    // h2-14 prevents sending a window update in this state

    return;

  }

  // right now mClientReceiveWindow is the lower push limit

  // bump it up to the pull limit set by the channel or session

  // don't allow windows less than push

  uint32_t bump = 0;

  nsHttpTransaction *trans = mTransaction->QueryHttpTransaction();

  if (trans && trans->InitialRwin()) {

    bump = (trans->InitialRwin() > mClientReceiveWindow) ?

      (trans->InitialRwin() - mClientReceiveWindow) : 0;

  } else {

    MOZ_ASSERT(mSession->InitialRwin() >= mClientReceiveWindow);

    bump = mSession->InitialRwin() - mClientReceiveWindow;

  }

  LOG3(("AdjustInitialwindow increased flow control window %p 0x%X %u\n",

        this, stream->mStreamID, bump));

  if (!bump) { // nothing to do

    return;

  }

  EnsureBuffer(mTxInlineFrame, mTxInlineFrameUsed + Http2Session::kFrameHeaderBytes + 4,

               mTxInlineFrameUsed, mTxInlineFrameSize);

  uint8_t *packet = mTxInlineFrame.get() + mTxInlineFrameUsed;

  mTxInlineFrameUsed += Http2Session::kFrameHeaderBytes + 4;

  mSession->CreateFrameHeader(packet, 4,

                              Http2Session::FRAME_TYPE_WINDOW_UPDATE,

                              0, stream->mStreamID);

  mClientReceiveWindow += bump;

  bump = PR_htonl(bump);

  memcpy(packet + Http2Session::kFrameHeaderBytes, &bump, 4);

}

void

Http2Stream::AdjustPushedPriority()

{

  // >0 even numbered IDs are pushed streams. odd numbered IDs are pulled streams.

  // 0 is the sink for a pushed stream.

  if (mStreamID || !mPushSource)

    return;

  MOZ_ASSERT(mPushSource->mStreamID && !(mPushSource->mStreamID & 1));

  // If the pushed stream has recvd a FIN, there is no reason to update

  // the window

  if (mPushSource->RecvdFin() || mPushSource->RecvdReset())

    return;

  EnsureBuffer(mTxInlineFrame, mTxInlineFrameUsed + Http2Session::kFrameHeaderBytes + 5,

               mTxInlineFrameUsed, mTxInlineFrameSize);

  uint8_t *packet = mTxInlineFrame.get() + mTxInlineFrameUsed;

  mTxInlineFrameUsed += Http2Session::kFrameHeaderBytes + 5;

  mSession->CreateFrameHeader(packet, 5,

                              Http2Session::FRAME_TYPE_PRIORITY, 0,

                              mPushSource->mStreamID);

  mPushSource->SetPriority(mPriority);

  memset(packet + Http2Session::kFrameHeaderBytes, 0, 4);

  memcpy(packet + Http2Session::kFrameHeaderBytes + 4, &mPriorityWeight, 1);

  LOG3(("AdjustPushedPriority %p id 0x%X to weight %X\n", this, mPushSource->mStreamID,

        mPriorityWeight));

}

void

Http2Stream::UpdateTransportReadEvents(uint32_t count)

{

  mTotalRead += count;

  if (!mSocketTransport) {

    return;

  }

  mTransaction->OnTransportStatus(mSocketTransport,

                                  NS_NET_STATUS_RECEIVING_FROM,

                                  mTotalRead);

}

void

Http2Stream::UpdateTransportSendEvents(uint32_t count)

{

  mTotalSent += count;

  // normally on non-windows platform we use TCP autotuning for

  // the socket buffers, and this works well (managing enough

  // buffers for BDP while conserving memory) for HTTP even when

  // it creates really deep queues. However this 'buffer bloat' is

  // a problem for http/2 because it ruins the low latency properties

  // necessary for PING and cancel to work meaningfully.

  //

  // If this stream represents a large upload, disable autotuning for

  // the session and cap the send buffers by default at 128KB.

  // (10Mbit/sec @ 100ms)

  //

  uint32_t bufferSize = gHttpHandler->SpdySendBufferSize();

  if ((mTotalSent > bufferSize) && !mSetTCPSocketBuffer) {

    mSetTCPSocketBuffer = 1;

    mSocketTransport->SetSendBufferSize(bufferSize);

  }

  if (mUpstreamState != SENDING_FIN_STREAM)

    mTransaction->OnTransportStatus(mSocketTransport,

                                    NS_NET_STATUS_SENDING_TO,

                                    mTotalSent);

  if (!mSentWaitingFor && !mRequestBodyLenRemaining) {

    mSentWaitingFor = 1;

    mTransaction->OnTransportStatus(mSocketTransport,

                                    NS_NET_STATUS_WAITING_FOR,

                                    0);

  }

}

nsresult

Http2Stream::TransmitFrame(const char *buf,

                           uint32_t *countUsed,

                           bool forceCommitment)

{

  // If TransmitFrame returns SUCCESS than all the data is sent (or at least

  // buffered at the session level), if it returns WOULD_BLOCK then none of

  // the data is sent.

  // You can call this function with no data and no out parameter in order to

  // flush internal buffers that were previously blocked on writing. You can

  // of course feed new data to it as well.

  LOG3(("Http2Stream::TransmitFrame %p inline=%d stream=%d",

        this, mTxInlineFrameUsed, mTxStreamFrameSize));

  if (countUsed)

    *countUsed = 0;

  if (!mTxInlineFrameUsed) {

    MOZ_ASSERT(!buf);