Pull out flow control functionality from ReliableQuicStream into a new

net/quic/quic_stream_sequencer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_stream_sequencer.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 101 matching lines @@
   // buffering if the stream is unable to process it.
   if (!blocked_ && byte_offset == num_bytes_consumed_) {
     DVLOG(1) << "Processing byte offset " << byte_offset;
     size_t bytes_consumed = 0;
     for (size_t i = 0; i < data.Size(); ++i) {
       bytes_consumed += stream_->ProcessRawData(
           static_cast<char*>(data.iovec()[i].iov_base),
           data.iovec()[i].iov_len);
     }
     num_bytes_consumed_ += bytes_consumed;
+    stream_->flow_controller()->AddBytesConsumed(bytes_consumed);
     stream_->MaybeSendWindowUpdate();
 
     if (MaybeCloseStream()) {
       return true;
     }
     if (bytes_consumed > data_len) {
       stream_->Reset(QUIC_ERROR_PROCESSING_STREAM);
       return false;
     } else if (bytes_consumed == data_len) {
       FlushBufferedFrames();
       return true;  // it's safe to ack this frame.
     } else {
       // Set ourselves up to buffer what's left.
       data_len -= bytes_consumed;
       data.Consume(bytes_consumed);
       byte_offset += bytes_consumed;
     }
   }
 
   // Buffer any remaining data to be consumed by the stream when ready.
   for (size_t i = 0; i < data.Size(); ++i) {
     DVLOG(1) << "Buffering stream data at offset " << byte_offset;
     const iovec& iov = data.iovec()[i];
     frames_.insert(make_pair(
         byte_offset, string(static_cast<char*>(iov.iov_base), iov.iov_len)));
     byte_offset += iov.iov_len;
     num_bytes_buffered_ += iov.iov_len;
+    stream_->flow_controller()->AddBytesBuffered(iov.iov_len);
   }
   return true;
 }
 
 void QuicStreamSequencer::CloseStreamAtOffset(QuicStreamOffset offset) {
   const QuicStreamOffset kMaxOffset = numeric_limits<QuicStreamOffset>::max();
 
   // If we have a scheduled termination or close, any new offset should match
   // it.
   if (close_offset_ != kMaxOffset && offset != close_offset_) {
@@ skipping 131 matching lines @@
       return;
     }
   }
   MaybeCloseStream();
 }
 
 void QuicStreamSequencer::RecordBytesConsumed(size_t bytes_consumed) {
   num_bytes_consumed_ += bytes_consumed;
   num_bytes_buffered_ -= bytes_consumed;
 
+  stream_->flow_controller()->AddBytesConsumed(bytes_consumed);
+  stream_->flow_controller()->RemoveBytesBuffered(bytes_consumed);
   stream_->MaybeSendWindowUpdate();
 }
 
 }  // namespace net