Introduces QuicStreamSequencerBufferInterface with one implementation. Refactor, no behavior change.

net/quic/quic_frame_list.cc

 // Copyright (c) 2015 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_frame_list.h"
 
 #include "base/logging.h"
 
 namespace net {
 
 QuicFrameList::FrameData::FrameData(QuicStreamOffset offset,
                                     string segment,
                                     const QuicTime timestamp)
     : offset(offset), segment(segment), timestamp(timestamp) {}
 
 QuicFrameList::QuicFrameList() {}
 
 QuicFrameList::~QuicFrameList() {
   Clear();
 }
 
-QuicErrorCode QuicFrameList::WriteAtOffset(QuicStreamOffset offset,
-                                           StringPiece data,
-                                           QuicTime timestamp,
-                                           size_t* const bytes_written) {
-  *bytes_written = 0;
+void QuicFrameList::Clear() {
+  frame_list_.clear();
+  num_bytes_buffered_ = 0;
+}
+
+bool QuicFrameList::Empty() const {
+  return frame_list_.empty();
+}
+
+QuicErrorCode QuicFrameList::OnStreamData(QuicStreamOffset offset,
+                                          StringPiece data,
+                                          QuicTime timestamp,
+                                          size_t* const bytes_buffered) {
+  *bytes_buffered = 0;
   const size_t data_len = data.size();
   auto insertion_point = FindInsertionPoint(offset, data_len);
   if (IsDuplicate(offset, data_len, insertion_point)) {
     return QUIC_NO_ERROR;
   }
 
   if (FrameOverlapsBufferedData(offset, data_len, insertion_point)) {
     return QUIC_INVALID_STREAM_DATA;
   }
 
   DVLOG(1) << "Buffering stream data at offset " << offset;
   // Inserting an empty string and then copying to avoid the extra copy.
   insertion_point =
       frame_list_.insert(insertion_point, FrameData(offset, "", timestamp));
   data.CopyToString(&insertion_point->segment);
-  *bytes_written = data_len;
+  *bytes_buffered = data_len;
+  num_bytes_buffered_ += data_len;
   return QUIC_NO_ERROR;
 }
 
 // Finds the place the frame should be inserted.  If an identical frame is
 // present, stops on the identical frame.
 list<QuicFrameList::FrameData>::iterator QuicFrameList::FindInsertionPoint(
     QuicStreamOffset offset,
     size_t len) {
   if (frame_list_.empty()) {
     return frame_list_.begin();
@@ skipping 75 matching lines @@
   return index;
 }
 
 bool QuicFrameList::GetReadableRegion(iovec* iov, QuicTime* timestamp) const {
   list<FrameData>::const_iterator it = frame_list_.begin();
   if (it == frame_list_.end() || it->offset != total_bytes_read_) {
     return false;
   }
   iov->iov_base = static_cast<void*>(const_cast<char*>(it->segment.data()));
   iov->iov_len = it->segment.size();
-  if (timestamp) {
-    *timestamp = it->timestamp;
-  }
+  *timestamp = it->timestamp;
   return true;
 }
 
-bool QuicFrameList::IncreaseTotalReadAndInvalidate(size_t bytes_used) {
+bool QuicFrameList::MarkConsumed(size_t bytes_used) {
   size_t end_offset = total_bytes_read_ + bytes_used;
   while (!frame_list_.empty() && end_offset != total_bytes_read_) {
     list<FrameData>::iterator it = frame_list_.begin();
     if (it->offset != total_bytes_read_) {
       return false;
     }
 
     if (it->offset + it->segment.length() <= end_offset) {
       total_bytes_read_ += it->segment.length();
+      num_bytes_buffered_ -= it->segment.length();
       // This chunk is entirely consumed.
       frame_list_.erase(it);
       continue;
     }
 
     // Partially consume this frame.
     size_t delta = end_offset - it->offset;
     total_bytes_read_ += delta;
+    num_bytes_buffered_ -= delta;
     string new_data = it->segment.substr(delta);
     const QuicTime timestamp = it->timestamp;
     frame_list_.erase(it);
     frame_list_.push_front(FrameData(total_bytes_read_, new_data, timestamp));
     break;
   }
   return true;
 }
 
-size_t QuicFrameList::ReadvAndInvalidate(const struct iovec* iov,
-                                         size_t iov_len) {
+size_t QuicFrameList::Readv(const struct iovec* iov, size_t iov_len) {
   list<FrameData>::iterator it = frame_list_.begin();
   size_t iov_index = 0;
   size_t iov_offset = 0;
   size_t frame_offset = 0;
   QuicStreamOffset initial_bytes_consumed = total_bytes_read_;
 
   while (iov_index < iov_len && it != frame_list_.end() &&
          it->offset == total_bytes_read_) {
     int bytes_to_read = std::min(iov[iov_index].iov_len - iov_offset,
                                  it->segment.size() - frame_offset);
 
     char* iov_ptr = static_cast<char*>(iov[iov_index].iov_base) + iov_offset;
     memcpy(iov_ptr, it->segment.data() + frame_offset, bytes_to_read);
     frame_offset += bytes_to_read;
     iov_offset += bytes_to_read;
 
     if (iov[iov_index].iov_len == iov_offset) {
       // We've filled this buffer.
       iov_offset = 0;
       ++iov_index;
     }
     if (it->segment.size() == frame_offset) {
       // We've copied this whole frame
       total_bytes_read_ += it->segment.size();
+      num_bytes_buffered_ -= it->segment.size();
       frame_list_.erase(it);
       it = frame_list_.begin();
       frame_offset = 0;
     }
   }
   // Done copying.  If there is a partial frame, update it.
   if (frame_offset != 0) {
     frame_list_.push_front(FrameData(it->offset + frame_offset,
                                      it->segment.substr(frame_offset),
                                      it->timestamp));
     frame_list_.erase(it);
     total_bytes_read_ += frame_offset;
+    num_bytes_buffered_ -= frame_offset;
   }
   return total_bytes_read_ - initial_bytes_consumed;
 }
 
 size_t QuicFrameList::FlushBufferedFrames() {
   QuicStreamOffset initial_bytes_consumed = total_bytes_read_;
   if (!frame_list_.empty()) {
     // Consume all of the bytes up to the last byte yet seen, including the
     // ones that haven't arrived yet.
     auto it = frame_list_.back();
     total_bytes_read_ = it.offset + it.segment.length();
     frame_list_.clear();
   }
   return total_bytes_read_ - initial_bytes_consumed;
 }
 
 bool QuicFrameList::HasBytesToRead() const {
   return !frame_list_.empty() &&
          frame_list_.begin()->offset == total_bytes_read_;
 }
+
+QuicStreamOffset QuicFrameList::BytesConsumed() const {
+  return total_bytes_read_;
+}
+
+size_t QuicFrameList::BytesBuffered() const {
+  return num_bytes_buffered_;
+}
+
 }  // namespace net_quic