Revert 198736 "Land Recent QUIC changes"

trunk/src/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 "base/logging.h"
@@ skipping 64 matching lines @@
     // Silently ignore duplicates.
     return true;
   }
 
   QuicStreamOffset byte_offset = frame.offset;
   const char* data = frame.data.data();
   size_t data_len = frame.data.size();
 
   if (byte_offset == num_bytes_consumed_) {
     DVLOG(1) << "Processing byte offset " << byte_offset;
-    size_t bytes_consumed = stream_->ProcessRawData(data, data_len);
+    size_t bytes_consumed = stream_->ProcessData(data, data_len);
     num_bytes_consumed_ += bytes_consumed;
 
     if (MaybeCloseStream()) {
       return true;
     }
     if (bytes_consumed > data_len) {
       stream_->Close(QUIC_SERVER_ERROR_PROCESSING_STREAM);
       return false;
     } else if (bytes_consumed == data_len) {
       FlushBufferedFrames();
@@ skipping 36 matching lines @@
              << num_bytes_consumed_ << " of " << close_offset_
              << " bytes.";
     // Technically it's an error if num_bytes_consumed isn't exactly
     // equal, but error handling seems silly at this point.
     stream_->TerminateFromPeer(half_close_);
     return true;
   }
   return false;
 }
 
-int QuicStreamSequencer::GetReadableRegions(iovec* iov, int iov_len) {
-  FrameMap::iterator it = frames_.begin();
-  int index = 0;
-  uint64 offset = num_bytes_consumed_;
-  while (it != frames_.end() && index < iov_len) {
-    if (it->first != offset) return index;
-
-    iov[index].iov_base = static_cast<void*>(
-        const_cast<char*>(it->second.data()));
-    iov[index].iov_len = it->second.size();
-    offset += it->second.size();
-
-    ++index;
-    ++it;
-  }
-  return index;
-}
-
-int QuicStreamSequencer::Readv(const struct iovec* iov, int iov_len) {
-  FrameMap::iterator it = frames_.begin();
-  int iov_index = 0;
-  size_t iov_offset = 0;
-  size_t frame_offset = 0;
-  size_t initial_bytes_consumed = num_bytes_consumed_;
-
-  while (iov_index < iov_len &&
-         it != frames_.end() &&
-         it->first == num_bytes_consumed_) {
-    int bytes_to_read = min(iov[iov_index].iov_len - iov_offset,
-                            it->second.size() - frame_offset);
-
-    char* iov_ptr = static_cast<char*>(iov[iov_index].iov_base) + iov_offset;
-    memcpy(iov_ptr,
-           it->second.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->second.size() == frame_offset) {
-      // We've copied this whole frame
-      num_bytes_consumed_ += it->second.size();
-      frames_.erase(it);
-      it = frames_.begin();
-      frame_offset = 0;
-    }
-  }
-  // We've finished copying.  If we have a partial frame, update it.
-  if (frame_offset != 0) {
-    frames_.insert(make_pair(it->first + frame_offset,
-                             it->second.substr(frame_offset)));
-    frames_.erase(frames_.begin());
-    num_bytes_consumed_ += frame_offset;
-  }
-  return num_bytes_consumed_ - initial_bytes_consumed;
-}
-
-void QuicStreamSequencer::MarkConsumed(size_t num_bytes_consumed) {
-  size_t end_offset = num_bytes_consumed_ + num_bytes_consumed;
-  while (!frames_.empty()) {
-    FrameMap::iterator it = frames_.begin();
-    if (it->first + it->second.length() <= end_offset) {
-      // This chunk is entirely consumed.
-      frames_.erase(it);
-      continue;
-    }
-
-    if (it->first != end_offset) {
-      // Partially consume this frame.
-      frames_.insert(make_pair(end_offset,
-                               it->second.substr(end_offset - it->first)));
-      frames_.erase(it);
-    }
-    break;
-  }
-  num_bytes_consumed_ = end_offset;
-}
-
 bool QuicStreamSequencer::HasBytesToRead() const {
   FrameMap::const_iterator it = frames_.begin();
 
   return it != frames_.end() && it->first == num_bytes_consumed_;
 }
 
 bool QuicStreamSequencer::IsHalfClosed() const {
   return num_bytes_consumed_ >= close_offset_;
 }
 
 bool QuicStreamSequencer::IsClosed() const {
   return num_bytes_consumed_ >= close_offset_ && half_close_ == false;
 }
 
 bool QuicStreamSequencer::IsDuplicate(const QuicStreamFrame& frame) const {
   // A frame is duplicate if the frame offset is smaller than our bytes consumed
   // or we have stored the frame in our map.
   // TODO(pwestin): Is it possible that a new frame contain more data even if
   // the offset is the same?
   return frame.offset < num_bytes_consumed_ ||
       frames_.find(frame.offset) != frames_.end();
 }
 
 void QuicStreamSequencer::FlushBufferedFrames() {
   FrameMap::iterator it = frames_.find(num_bytes_consumed_);
   while (it != frames_.end()) {
     DVLOG(1) << "Flushing buffered packet at offset " << it->first;
     string* data = &it->second;
-    size_t bytes_consumed = stream_->ProcessRawData(data->c_str(),
-                                                    data->size());
+    size_t bytes_consumed = stream_->ProcessData(data->c_str(), data->size());
     num_bytes_consumed_ += bytes_consumed;
     if (MaybeCloseStream()) {
       return;
     }
     if (bytes_consumed > data->size()) {
       stream_->Close(QUIC_SERVER_ERROR_PROCESSING_STREAM);  // Programming error
       return;
     } else if (bytes_consumed == data->size()) {
       frames_.erase(it);
       it = frames_.find(num_bytes_consumed_);
     } else {
       string new_data = it->second.substr(bytes_consumed);
       frames_.erase(it);
       frames_.insert(make_pair(num_bytes_consumed_, new_data));
       return;
     }
   }
 }
 
 }  // namespace net