Land Recent QUIC Changes.

net/quic/reliable_quic_stream.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/reliable_quic_stream.h"
 
 #include "base/logging.h"
 #include "net/quic/iovector.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_session.h"
@@ skipping 148 matching lines @@
           GetReceivedFlowControlWindow(session),
           GetInitialStreamFlowControlWindowToSend(session),
           GetInitialStreamFlowControlWindowToSend(session)),
       connection_flow_controller_(session_->flow_controller()),
       stream_contributes_to_connection_flow_control_(true) {
 }
 
 ReliableQuicStream::~ReliableQuicStream() {
 }
 
-bool ReliableQuicStream::OnStreamFrame(const QuicStreamFrame& frame) {
+void ReliableQuicStream::OnStreamFrame(const QuicStreamFrame& frame) {
   if (read_side_closed_) {
     DVLOG(1) << ENDPOINT << "Ignoring frame " << frame.stream_id;
     // We don't want to be reading: blackhole the data.
-    return true;
+    return;
   }
 
   if (frame.stream_id != id_) {
-    LOG(ERROR) << "Error!";
-    return false;
+    session_->connection()->SendConnectionClose(QUIC_INTERNAL_ERROR);
+    return;
   }
 
   if (frame.fin) {
     fin_received_ = true;
   }
 
   // This count include duplicate data received.
   size_t frame_payload_size = frame.data.TotalBufferSize();
   stream_bytes_read_ += frame_payload_size;
 
   // Flow control is interested in tracking highest received offset.
   if (MaybeIncreaseHighestReceivedOffset(frame.offset + frame_payload_size)) {
     // As the highest received offset has changed, we should check to see if
     // this is a violation of flow control.
     if (flow_controller_.FlowControlViolation() ||
         connection_flow_controller_->FlowControlViolation()) {
       session_->connection()->SendConnectionClose(
           QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA);
-      return false;
+      return;
     }
   }
 
-  return sequencer_.OnStreamFrame(frame);
+  sequencer_.OnStreamFrame(frame);
 }
 
 int ReliableQuicStream::num_frames_received() const {
   return sequencer_.num_frames_received();
 }
 
 int ReliableQuicStream::num_duplicate_frames_received() const {
   return sequencer_.num_duplicate_frames_received();
 }
 
@@ skipping 322 matching lines @@
 
 bool ReliableQuicStream::IsFlowControlBlocked() {
   if (flow_controller_.IsBlocked()) {
     return true;
   }
   return stream_contributes_to_connection_flow_control_ &&
       connection_flow_controller_->IsBlocked();
 }
 
 }  // namespace net