Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(389)

Unified Diff: net/quic/quic_stream_sequencer.cc

Issue 2193073003: Move shared files in net/quic/ into net/quic/core/ (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: io_thread_unittest.cc Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/quic/quic_stream_sequencer.h ('k') | net/quic/quic_stream_sequencer_buffer.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/quic/quic_stream_sequencer.cc
diff --git a/net/quic/quic_stream_sequencer.cc b/net/quic/quic_stream_sequencer.cc
deleted file mode 100644
index f6f0182507ba86b9e67c4d5022caac74179f424f..0000000000000000000000000000000000000000
--- a/net/quic/quic_stream_sequencer.cc
+++ /dev/null
@@ -1,218 +0,0 @@
-// 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>
-
-#include "base/logging.h"
-#include "base/strings/string_number_conversions.h"
-#include "net/quic/quic_bug_tracker.h"
-#include "net/quic/quic_clock.h"
-#include "net/quic/quic_flags.h"
-#include "net/quic/quic_protocol.h"
-#include "net/quic/quic_stream_sequencer_buffer.h"
-#include "net/quic/quic_utils.h"
-#include "net/quic/reliable_quic_stream.h"
-
-using base::IntToString;
-using base::StringPiece;
-using std::min;
-using std::numeric_limits;
-using std::string;
-
-namespace net {
-
-QuicStreamSequencer::QuicStreamSequencer(ReliableQuicStream* quic_stream,
- const QuicClock* clock)
- : stream_(quic_stream),
- buffered_frames_(kStreamReceiveWindowLimit),
- close_offset_(numeric_limits<QuicStreamOffset>::max()),
- blocked_(false),
- num_frames_received_(0),
- num_duplicate_frames_received_(0),
- 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.data_length;
-
- 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.data_buffer, frame.data_length),
- clock_->ApproximateNow(), &bytes_written, &error_details);
- if (result != QUIC_NO_ERROR) {
- string details = "Stream" + base::Uint64ToString(stream_->id()) + ": " +
- QuicUtils::ErrorToString(result) + ": " + error_details +
- "\nPeer Address: " +
- stream_->PeerAddressOfLatestPacket().ToString();
- DLOG(WARNING) << QuicUtils::ErrorToString(result);
- DLOG(WARNING) << details;
- stream_->CloseConnectionWithDetails(result, details);
- return;
- }
-
- if (bytes_written == 0) {
- ++num_duplicate_frames_received_;
- // Silently ignore duplicates.
- return;
- }
-
- if (byte_offset > buffered_frames_.BytesConsumed()) {
- ++num_early_frames_received_;
- }
-
- if (blocked_) {
- return;
- }
-
- if (byte_offset == buffered_frames_.BytesConsumed()) {
- if (ignore_read_data_) {
- FlushBufferedFrames();
- } else {
- stream_->OnDataAvailable();
- }
- }
-}
-
-void QuicStreamSequencer::CloseStreamAtOffset(QuicStreamOffset offset) {
- const QuicStreamOffset kMaxOffset = numeric_limits<QuicStreamOffset>::max();
-
- // If there is a scheduled close, the new offset should match it.
- if (close_offset_ != kMaxOffset && offset != close_offset_) {
- stream_->Reset(QUIC_MULTIPLE_TERMINATION_OFFSETS);
- return;
- }
-
- close_offset_ = offset;
-
- MaybeCloseStream();
-}
-
-bool QuicStreamSequencer::MaybeCloseStream() {
- if (blocked_ || !IsClosed()) {
- return false;
- }
-
- DVLOG(1) << "Passing up termination, as we've processed "
- << buffered_frames_.BytesConsumed() << " of " << close_offset_
- << " bytes.";
- // This will cause the stream to consume the FIN.
- // Technically it's an error if |num_bytes_consumed| isn't exactly
- // equal to |close_offset|, but error handling seems silly at this point.
- if (ignore_read_data_) {
- // The sequencer is discarding stream data and must notify the stream on
- // receipt of a FIN because the consumer won't.
- stream_->OnFinRead();
- } else {
- stream_->OnDataAvailable();
- }
- buffered_frames_.Clear();
- return true;
-}
-
-int QuicStreamSequencer::GetReadableRegions(iovec* iov, size_t iov_len) const {
- DCHECK(!blocked_);
- return buffered_frames_.GetReadableRegions(iov, iov_len);
-}
-
-bool QuicStreamSequencer::GetReadableRegion(iovec* iov,
- QuicTime* timestamp) const {
- DCHECK(!blocked_);
- return buffered_frames_.GetReadableRegion(iov, timestamp);
-}
-
-int QuicStreamSequencer::Readv(const struct iovec* iov, size_t iov_len) {
- DCHECK(!blocked_);
- size_t bytes_read = buffered_frames_.Readv(iov, iov_len);
- stream_->AddBytesConsumed(bytes_read);
- return static_cast<int>(bytes_read);
-}
-
-bool QuicStreamSequencer::HasBytesToRead() const {
- return buffered_frames_.HasBytesToRead();
-}
-
-bool QuicStreamSequencer::IsClosed() const {
- return buffered_frames_.BytesConsumed() >= close_offset_;
-}
-
-void QuicStreamSequencer::MarkConsumed(size_t num_bytes_consumed) {
- DCHECK(!blocked_);
- bool result = buffered_frames_.MarkConsumed(num_bytes_consumed);
- if (!result) {
- QUIC_BUG << "Invalid argument to MarkConsumed."
- << " expect to consume: " << num_bytes_consumed
- << ", but not enough bytes available. " << DebugString();
- stream_->Reset(QUIC_ERROR_PROCESSING_STREAM);
- return;
- }
- stream_->AddBytesConsumed(num_bytes_consumed);
-}
-
-void QuicStreamSequencer::SetBlockedUntilFlush() {
- blocked_ = true;
-}
-
-void QuicStreamSequencer::SetUnblocked() {
- blocked_ = false;
- if (IsClosed() || HasBytesToRead()) {
- stream_->OnDataAvailable();
- }
-}
-
-void QuicStreamSequencer::StopReading() {
- if (ignore_read_data_) {
- return;
- }
- ignore_read_data_ = true;
- FlushBufferedFrames();
-}
-
-void QuicStreamSequencer::FlushBufferedFrames() {
- DCHECK(ignore_read_data_);
- size_t bytes_flushed = buffered_frames_.FlushBufferedFrames();
- DVLOG(1) << "Flushing buffered data at offset "
- << buffered_frames_.BytesConsumed() << " length " << bytes_flushed
- << " for stream " << stream_->id();
- stream_->AddBytesConsumed(bytes_flushed);
- MaybeCloseStream();
-}
-
-size_t QuicStreamSequencer::NumBytesBuffered() const {
- return buffered_frames_.BytesBuffered();
-}
-
-QuicStreamOffset QuicStreamSequencer::NumBytesConsumed() const {
- return buffered_frames_.BytesConsumed();
-}
-
-const string QuicStreamSequencer::DebugString() const {
- // clang-format off
- return "QuicStreamSequencer:"
- "\n bytes buffered: " + IntToString(NumBytesBuffered()) +
- "\n bytes consumed: " + IntToString( NumBytesConsumed()) +
- "\n has bytes to read: " + (HasBytesToRead() ? "true" : "false") +
- "\n frames received: " + IntToString(num_frames_received()) +
- "\n close offset bytes: " + IntToString( close_offset_) +
- "\n is closed: " + (IsClosed() ? "true" : "false");
- // clang-format on
-}
-
-} // namespace net
« no previous file with comments | « net/quic/quic_stream_sequencer.h ('k') | net/quic/quic_stream_sequencer_buffer.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698