Deprecate FLAGS_quic_consolidate_onstreamframe_errors

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 <string>
 #include <utility>
@@ skipping 24 matching lines @@
       num_early_frames_received_(0),
       clock_(clock),
       ignore_read_data_(false) {}
 
 QuicStreamSequencer::~QuicStreamSequencer() {}
 
 void QuicStreamSequencer::OnStreamFrame(const QuicStreamFrame& frame) {
   ++num_frames_received_;
   const QuicStreamOffset byte_offset = frame.offset;
   const size_t data_len = frame.frame_length;
-  bool consolidate_errors = FLAGS_quic_consolidate_onstreamframe_errors;
-  if (!consolidate_errors && data_len == 0 && !frame.fin) {
-    // Stream frames must have data or a fin flag.
-    LOG(WARNING) << "QUIC_INVALID_STREAM_FRAM: Empty stream frame "
-                    "without FIN set.";
-    stream_->CloseConnectionWithDetails(QUIC_EMPTY_STREAM_FRAME_NO_FIN,
-                                        "Empty stream frame without FIN set.");
-    return;
-  }
 
   if (frame.fin) {
     CloseStreamAtOffset(frame.offset + data_len);
     if (data_len == 0) {
       return;
     }
   }
   size_t bytes_written;
   string error_details;
   QuicErrorCode result = buffered_frames_.OnStreamData(
       byte_offset, StringPiece(frame.frame_buffer, frame.frame_length),
       clock_->ApproximateNow(), &bytes_written, &error_details);
-  if (!consolidate_errors) {
-    if (result == QUIC_OVERLAPPING_STREAM_DATA) {
-      LOG(WARNING) << "QUIC_INVALID_STREAM_FRAME: Stream frame "
-                      "overlaps with buffered data.";
-      stream_->CloseConnectionWithDetails(
-          QUIC_EMPTY_STREAM_FRAME_NO_FIN,
-          "Stream frame overlaps with buffered data.");
-      return;
-    }
-  } else {
-    if (result != QUIC_NO_ERROR) {
-      LOG(WARNING) << QuicUtils::ErrorToString(result) << ": " << error_details;
-      stream_->CloseConnectionWithDetails(result, error_details);
-      return;
-    }
+  if (result != QUIC_NO_ERROR) {
+    DLOG(WARNING) << QuicUtils::ErrorToString(result);
+    DLOG(WARNING) << error_details;
+    stream_->CloseConnectionWithDetails(result, error_details);
+    return;
   }
 
-  if ((consolidate_errors || result == QUIC_NO_ERROR) && bytes_written == 0) {
+  if (bytes_written == 0) {
     ++num_duplicate_frames_received_;
     // Silently ignore duplicates.
     return;
   }
 
   if (byte_offset > buffered_frames_.BytesConsumed()) {
     ++num_early_frames_received_;
   }
 
   if (blocked_) {
@@ skipping 115 matching lines @@
 
 size_t QuicStreamSequencer::NumBytesBuffered() const {
   return buffered_frames_.BytesBuffered();
 }
 
 QuicStreamOffset QuicStreamSequencer::NumBytesConsumed() const {
   return buffered_frames_.BytesConsumed();
 }
 
 }  // namespace net