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

net/quic/quic_frame_list.cc

Index: net/quic/quic_frame_list.cc
diff --git a/net/quic/quic_frame_list.cc b/net/quic/quic_frame_list.cc
index 5a6209eb6846020bf31d98aed3b21517d222bc64..862e34f7ceda76db83afe1b82c6f572a79c18c3f 100644
--- a/net/quic/quic_frame_list.cc
+++ b/net/quic/quic_frame_list.cc
@@ -19,11 +19,20 @@ 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)) {
@@ -39,7 +48,8 @@ QuicErrorCode QuicFrameList::WriteAtOffset(QuicStreamOffset offset,
   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;
 }
 
@@ -135,13 +145,11 @@ bool QuicFrameList::GetReadableRegion(iovec* iov, QuicTime* timestamp) const {
   }
   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();
@@ -151,6 +159,7 @@ bool QuicFrameList::IncreaseTotalReadAndInvalidate(size_t bytes_used) {
 
     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;
@@ -159,6 +168,7 @@ bool QuicFrameList::IncreaseTotalReadAndInvalidate(size_t bytes_used) {
     // 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);
@@ -168,8 +178,7 @@ bool QuicFrameList::IncreaseTotalReadAndInvalidate(size_t bytes_used) {
   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;
@@ -194,6 +203,7 @@ size_t QuicFrameList::ReadvAndInvalidate(const struct iovec* iov,
     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;
@@ -206,6 +216,7 @@ size_t QuicFrameList::ReadvAndInvalidate(const struct iovec* iov,
                                      it->timestamp));
     frame_list_.erase(it);
     total_bytes_read_ += frame_offset;
+    num_bytes_buffered_ -= frame_offset;
   }
   return total_bytes_read_ - initial_bytes_consumed;
 }
@@ -226,4 +237,13 @@ 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