relnote: Implement server push methods in QuicSimpleServerSession. Only modify toy Quic server, not…

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 "base/strings/stringprintf.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_bug_tracker.h"
@@ skipping 152 matching lines @@
 
 void QuicSession::OnRstStream(const QuicRstStreamFrame& frame) {
   if (ContainsKey(static_stream_map_, frame.stream_id)) {
     connection()->SendConnectionCloseWithDetails(
         QUIC_INVALID_STREAM_ID, "Attempt to reset a static stream");
     return;
   }
 
   ReliableQuicStream* stream = GetOrCreateDynamicStream(frame.stream_id);
   if (!stream) {
-    // 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);
+    HandleRstOnValidNonexistentStream(frame);
     return;  // Errors are handled by GetStream.
   }
 
   stream->OnStreamReset(frame);
 }
 
 void QuicSession::OnGoAway(const QuicGoAwayFrame& frame) {
   DCHECK(frame.last_good_stream_id < next_outgoing_stream_id_);
 }
 
@@ skipping 317 matching lines @@
   flow_controller_.UpdateReceiveWindowSize(session_window);
   // Inform all existing streams about the new window.
   for (auto const& kv : static_stream_map_) {
     kv.second->flow_controller()->UpdateReceiveWindowSize(stream_window);
   }
   for (auto const& kv : dynamic_stream_map_) {
     kv.second->flow_controller()->UpdateReceiveWindowSize(stream_window);
   }
 }
 
+void QuicSession::HandleFrameOnNonexistentOutgoingStream(
+    QuicStreamId stream_id) {
+  DCHECK(!IsClosedStream(stream_id));
+  // Received a frame for a locally-created stream that is not currently
+  // active. This is an error.
+  CloseConnectionWithDetails(QUIC_INVALID_STREAM_ID,
+                             "Data for nonexistent stream");
+}
+
+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);
+  }
+}
+
 void QuicSession::OnNewStreamFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kMinimumFlowControlSendWindow) {
     LOG(ERROR) << "Peer sent us an invalid stream flow control send window: "
                << new_window
                << ", below default: " << kMinimumFlowControlSendWindow;
     if (connection_->connected()) {
       connection_->SendConnectionCloseWithDetails(
           QUIC_FLOW_CONTROL_INVALID_WINDOW, "New stream window too low");
     }
     return;
@@ skipping 122 matching lines @@
   StreamMap::iterator it = dynamic_stream_map_.find(stream_id);
   if (it != dynamic_stream_map_.end()) {
     return it->second;
   }
 
   if (IsClosedStream(stream_id)) {
     return nullptr;
   }
 
   if (!IsIncomingStream(stream_id)) {
-    // Received a frame for a locally-created stream that is not currently
-    // active. This is an error.
-    CloseConnectionWithDetails(QUIC_INVALID_STREAM_ID,
-                               "Data for nonexistent stream");
+    HandleFrameOnNonexistentOutgoingStream(stream_id);
     return nullptr;
   }
 
   available_streams_.erase(stream_id);
 
   if (stream_id > largest_peer_created_stream_id_) {
     // Check if the new number of available streams would cause the number of
     // available streams to exceed the limit.  Note that the peer can create
     // only alternately-numbered streams.
     size_t additional_available_streams =
@@ skipping 153 matching lines @@
     }
   }
   return false;
 }
 
 bool QuicSession::IsIncomingStream(QuicStreamId id) const {
   return id % 2 != next_outgoing_stream_id_ % 2;
 }
 
 }  // namespace net