Land recent QUIC changes.

net/quic/reliable_quic_stream.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/reliable_quic_stream.h"
 
 #include "net/quic/quic_session.h"
 
 using base::StringPiece;
 
 namespace net {
 
 ReliableQuicStream::ReliableQuicStream(QuicStreamId id,
                                        QuicSession* session)
     : sequencer_(this),
       id_(id),
-      offset_(0),
       session_(session),
       visitor_(NULL),
       stream_bytes_read_(0),
       stream_bytes_written_(0),
       error_(QUIC_NO_ERROR),
       read_side_closed_(false),
       write_side_closed_(false),
       fin_buffered_(false),
       fin_sent_(false) {
 }
@@ skipping 13 matching lines @@
   return sequencer_.WillAcceptStreamFrame(frame);
 }
 
 bool ReliableQuicStream::OnStreamFrame(const QuicStreamFrame& frame) {
   DCHECK_EQ(frame.stream_id, id_);
   if (read_side_closed_) {
     DLOG(INFO) << "Ignoring frame " << frame.stream_id;
     // We don't want to be reading: blackhole the data.
     return true;
   }
+  // Note: This count include duplicate data received.
+  stream_bytes_read_ += frame.data.length();
 
   bool accepted = sequencer_.OnStreamFrame(frame);
 
   if (frame.fin) {
-    sequencer_.CloseStreamAtOffset(frame.offset + frame.data.size(),
-                                   true);
+    sequencer_.CloseStreamAtOffset(frame.offset + frame.data.size(), true);
   }
 
   return accepted;
 }
 
-void ReliableQuicStream::OnStreamReset(QuicErrorCode error,
-                                       QuicStreamOffset offset) {
+void ReliableQuicStream::OnStreamReset(QuicErrorCode error) {
   error_ = error;
-  sequencer_.CloseStreamAtOffset(offset, false);  // Full close.
+  TerminateFromPeer(false);  // Full close.
 }
 
 void ReliableQuicStream::ConnectionClose(QuicErrorCode error, bool from_peer) {
   error_ = error;
   if (from_peer) {
     TerminateFromPeer(false);
   } else {
     CloseWriteSide();
     CloseReadSide();
   }
 }
 
 void ReliableQuicStream::TerminateFromPeer(bool half_close) {
   if (!half_close) {
     CloseWriteSide();
   }
   CloseReadSide();
 }
 
 void ReliableQuicStream::Close(QuicErrorCode error) {
   error_ = error;
-  session()->SendRstStream(id(), error, offset_);
+  session()->SendRstStream(id(), error);
 }
 
 bool ReliableQuicStream::IsHalfClosed() const {
   return sequencer_.IsHalfClosed();
 }
 
 bool ReliableQuicStream::HasBytesToRead() const {
   return sequencer_.HasBytesToRead();
 }
 
@@ skipping 46 matching lines @@
 }
 
 QuicConsumedData ReliableQuicStream::WriteDataInternal(
     StringPiece data, bool fin) {
   if (write_side_closed_) {
     DLOG(ERROR) << "Attempt to write when the write side is closed";
     return QuicConsumedData(0, false);
   }
 
   QuicConsumedData consumed_data =
-      session()->WriteData(id(), data, offset_, fin);
-  offset_ += consumed_data.bytes_consumed;
+      session()->WriteData(id(), data, stream_bytes_written_, fin);
   stream_bytes_written_ += consumed_data.bytes_consumed;
   if (consumed_data.bytes_consumed == data.length()) {
     if (fin && consumed_data.fin_consumed) {
       fin_sent_ = true;
       CloseWriteSide();
     }
   } else {
     session_->MarkWriteBlocked(id());
   }
   return consumed_data;
@@ skipping 29 matching lines @@
   if (visitor_) {
     Visitor* visitor = visitor_;
     // Calling Visitor::OnClose() may result the destruction of the visitor,
     // so we need to ensure we don't call it again.
     visitor_ = NULL;
     visitor->OnClose(this);
   }
 }
 
 }  // namespace net