Landing Recent QUIC changes until 3:35 PM, Apr 26, 2017 UTC-4

net/quic/core/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/core/quic_session.h"
 
 #include <cstdint>
 #include <utility>
 
 #include "net/quic/core/quic_connection.h"
@@ skipping 59 matching lines @@
 void QuicSession::OnStreamFrame(const QuicStreamFrame& frame) {
   // TODO(rch) deal with the error case of stream id 0.
   QuicStreamId stream_id = frame.stream_id;
   QuicStream* stream = GetOrCreateStream(stream_id);
   if (!stream) {
     // The stream no longer exists, but we may still be interested in the
     // final stream byte offset sent by the peer. A frame with a FIN can give
     // us this offset.
     if (frame.fin) {
       QuicStreamOffset final_byte_offset = frame.offset + frame.data_length;
-      UpdateFlowControlOnFinalReceivedByteOffset(stream_id, final_byte_offset);
+      OnFinalByteOffsetReceived(stream_id, final_byte_offset);
     }
     return;
   }
   stream->OnStreamFrame(frame);
 }
 
 void QuicSession::OnRstStream(const QuicRstStreamFrame& frame) {
   if (QuicContainsKey(static_stream_map_, frame.stream_id)) {
     connection()->CloseConnection(
         QUIC_INVALID_STREAM_ID, "Attempt to reset a static stream",
@@ skipping 296 matching lines @@
       IsIncomingStream(stream_id)) {
     --num_draining_incoming_streams_;
   }
   draining_streams_.erase(stream_id);
 
   stream->OnClose();
   // Decrease the number of streams being emulated when a new one is opened.
   connection_->SetNumOpenStreams(dynamic_stream_map_.size());
 }
 
-void QuicSession::UpdateFlowControlOnFinalReceivedByteOffset(
+void QuicSession::OnFinalByteOffsetReceived(
     QuicStreamId stream_id,
     QuicStreamOffset final_byte_offset) {
   std::map<QuicStreamId, QuicStreamOffset>::iterator it =
       locally_closed_streams_highest_offset_.find(stream_id);
   if (it == locally_closed_streams_highest_offset_.end()) {
     return;
   }
 
   QUIC_DVLOG(1) << ENDPOINT << "Received final byte offset "
                 << final_byte_offset << " for stream " << stream_id;
@@ skipping 118 matching lines @@
 }
 
 void QuicSession::HandleRstOnValidNonexistentStream(
     const QuicRstStreamFrame& frame) {
   // If the stream is neither originally in active streams nor created in
   // GetOrCreateDynamicStream(), it could be a closed stream in which case its
   // final received byte offset need to be updated.
   if (IsClosedStream(frame.stream_id)) {
     // The RST frame contains the final byte offset for the stream: we can now
     // update the connection level flow controller if needed.
-    UpdateFlowControlOnFinalReceivedByteOffset(frame.stream_id,
-                                               frame.byte_offset);
+    OnFinalByteOffsetReceived(frame.stream_id, frame.byte_offset);
   }
 }
 
 void QuicSession::OnNewStreamFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kMinimumFlowControlSendWindow) {
     QUIC_LOG_FIRST_N(ERROR, 1)
         << "Peer sent us an invalid stream flow control send window: "
         << new_window << ", below default: " << kMinimumFlowControlSendWindow;
     if (connection_->connected()) {
       connection_->CloseConnection(
@@ skipping 265 matching lines @@
 bool QuicSession::HasDataToWrite() const {
   return write_blocked_streams_.HasWriteBlockedCryptoOrHeadersStream() ||
          write_blocked_streams_.HasWriteBlockedDataStreams() ||
          connection_->HasQueuedData();
 }
 
 void QuicSession::PostProcessAfterData() {
   closed_streams_.clear();
 }
 
+void QuicSession::OnAckNeedsRetransmittableFrame() {
+  flow_controller_.SendWindowUpdate();
+}
+
 size_t QuicSession::GetNumDynamicOutgoingStreams() const {
   DCHECK_GE(dynamic_stream_map_.size(), num_dynamic_incoming_streams_);
   return dynamic_stream_map_.size() - num_dynamic_incoming_streams_;
 }
 
 size_t QuicSession::GetNumDrainingOutgoingStreams() const {
   DCHECK_GE(draining_streams_.size(), num_draining_incoming_streams_);
   return draining_streams_.size() - num_draining_incoming_streams_;
 }
 
@@ skipping 24 matching lines @@
 
 size_t QuicSession::MaxAvailableStreams() const {
   return max_open_incoming_streams_ * kMaxAvailableStreamsMultiplier;
 }
 
 bool QuicSession::IsIncomingStream(QuicStreamId id) const {
   return id % 2 != next_outgoing_stream_id_ % 2;
 }
 
 }  // namespace net