Pull out flow control functionality from ReliableQuicStream into a new

net/quic/quic_session.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_session.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_headers_stream.h"
@@ skipping 267 matching lines @@
       return;
     }
     if (!connection_->CanWriteStreamData()) {
       return;
     }
     QuicStreamId stream_id = write_blocked_streams_.PopFront();
     if (stream_id == kCryptoStreamId) {
       has_pending_handshake_ = false;  // We just popped it.
     }
     ReliableQuicStream* stream = GetStream(stream_id);
-    if (stream != NULL && !stream->IsFlowControlBlocked()) {
+    if (stream != NULL && !stream->flow_controller()->IsBlocked()) {
       // If the stream can't write all bytes, it'll re-add itself to the blocked
       // list.
       stream->OnCanWrite();
     }
   }
 }
 
 bool QuicSession::HasPendingWrites() const {
   return write_blocked_streams_.HasWriteBlockedStreams();
 }
@@ skipping 83 matching lines @@
     if (new_flow_control_send_window < kDefaultFlowControlSendWindow) {
       LOG(DFATAL)
           << "Peer sent us an invalid flow control send window: "
           << new_flow_control_send_window
           << ", below default: " << kDefaultFlowControlSendWindow;
       connection_->SendConnectionClose(QUIC_FLOW_CONTROL_ERROR);
       return;
     }
     DataStreamMap::iterator it = stream_map_.begin();
     while (it != stream_map_.end()) {
-      it->second->UpdateFlowControlSendLimit(new_flow_control_send_window);
+      it->second->flow_controller()->UpdateSendWindowOffset(
+          new_flow_control_send_window);
       it++;
     }
   }
 }
 
 void QuicSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
   switch (event) {
     // TODO(satyamshekhar): Move the logic of setting the encrypter/decrypter
     // to QuicSession since it is the glue.
     case ENCRYPTION_FIRST_ESTABLISHED:
@@ skipping 148 matching lines @@
 }
 
 size_t QuicSession::GetNumOpenStreams() const {
   return stream_map_.size() + implicitly_created_streams_.size();
 }
 
 void QuicSession::MarkWriteBlocked(QuicStreamId id, QuicPriority priority) {
 #ifndef NDEBUG
   ReliableQuicStream* stream = GetStream(id);
   if (stream != NULL) {
-    if (stream->IsFlowControlBlocked()) {
-      LOG(DFATAL) << "Stream " << id << " is flow control blocked.";
+    if (stream->flow_controller()->IsBlocked()) {
+      LOG(DFATAL) << ENDPOINT << "Stream " << id
+                  << " is flow control blocked and write blocked!";
     }
     LOG_IF(DFATAL, priority != stream->EffectivePriority())
+        << ENDPOINT << "Stream " << id
         << "Priorities do not match.  Got: " << priority
         << " Expected: " << stream->EffectivePriority();
   } else {
     LOG(DFATAL) << "Marking unknown stream " << id << " blocked.";
   }
 #endif
 
   if (id == kCryptoStreamId) {
     DCHECK(!has_pending_handshake_);
     has_pending_handshake_ = true;
@@ skipping 14 matching lines @@
   NOTIMPLEMENTED();
   return false;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 }  // namespace net