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"
 #include "net/quic/quic_spdy_decompressor.h"
 #include "net/spdy/write_blocked_list.h"
 
@@ skipping 43 matching lines @@
       headers_decompressed_(false),
       priority_(kDefaultPriority),
       headers_id_(0),
       decompression_failed_(false),
       stream_error_(QUIC_STREAM_NO_ERROR),
       connection_error_(QUIC_NO_ERROR),
       read_side_closed_(false),
       write_side_closed_(false),
       priority_parsed_(false),
       fin_buffered_(false),
-      fin_sent_(false) {
+      fin_sent_(false),
+      is_server_(session_->is_server()) {
 }
 
 ReliableQuicStream::~ReliableQuicStream() {
 }
 
 bool ReliableQuicStream::WillAcceptStreamFrame(
     const QuicStreamFrame& frame) const {
   if (read_side_closed_) {
     return true;
   }
   if (frame.stream_id != id_) {
     LOG(ERROR) << "Error!";
     return false;
   }
   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;
+    DLOG(INFO) << ENDPOINT << "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);
 
   return accepted;
 }
@@ skipping 158 matching lines @@
     StringPiece data, bool fin) {
   struct iovec iov = {const_cast<char*>(data.data()),
                       static_cast<size_t>(data.size())};
   return WritevDataInternal(&iov, 1, fin);
 }
 
 QuicConsumedData ReliableQuicStream::WritevDataInternal(const struct iovec* iov,
                                                         int iov_count,
                                                         bool fin) {
   if (write_side_closed_) {
-    DLOG(ERROR) << "Attempt to write when the write side is closed";
+    DLOG(ERROR) << ENDPOINT << "Attempt to write when the write side is closed";
     return QuicConsumedData(0, false);
   }
 
   size_t write_length = 0u;
   for (int i = 0; i < iov_count; ++i) {
     write_length += iov[i].iov_len;
   }
   QuicConsumedData consumed_data =
       session()->WritevData(id(), iov, iov_count, stream_bytes_written_, fin);
   stream_bytes_written_ += consumed_data.bytes_consumed;
@@ skipping 11 matching lines @@
 }
 
 QuicPriority ReliableQuicStream::EffectivePriority() const {
   return priority();
 }
 
 void ReliableQuicStream::CloseReadSide() {
   if (read_side_closed_) {
     return;
   }
-  DLOG(INFO) << "Done reading from stream " << id();
+  DLOG(INFO) << ENDPOINT << "Done reading from stream " << id();
 
   read_side_closed_ = true;
   if (write_side_closed_) {
-    DLOG(INFO) << "Closing stream: " << id();
+    DLOG(INFO) << ENDPOINT << "Closing stream: " << id();
     session_->CloseStream(id());
   }
 }
 
 uint32 ReliableQuicStream::ProcessRawData(const char* data, uint32 data_len) {
   DCHECK_NE(0u, data_len);
   if (id() == kCryptoStreamId) {
     // The crypto stream does not use compression.
     return ProcessData(data, data_len);
   }
@@ skipping 20 matching lines @@
       total_bytes_consumed += ProcessData(data, data_len);
     }
     return total_bytes_consumed;
   }
 
   QuicHeaderId current_header_id =
       session_->decompressor()->current_header_id();
   // Ensure that this header id looks sane.
   if (headers_id_ < current_header_id ||
       headers_id_ > kMaxHeaderIdDelta + current_header_id) {
-    DVLOG(1) << "Invalid headers for stream: " << id()
+    DVLOG(1) << ENDPOINT
+             << "Invalid headers for stream: " << id()
              << " header_id: " << headers_id_
              << " current_header_id: " << current_header_id;
     session_->connection()->SendConnectionClose(QUIC_INVALID_HEADER_ID);
     return total_bytes_consumed;
   }
 
   // If we are head-of-line blocked on decompression, then back up.
   if (current_header_id != headers_id_) {
     session_->MarkDecompressionBlocked(headers_id_, id());
-    DVLOG(1) << "Unable to decompress header data for stream: " << id()
+    DVLOG(1) << ENDPOINT
+             << "Unable to decompress header data for stream: " << id()
              << " header_id: " << headers_id_;
     return total_bytes_consumed;
   }
 
   // Decompressed data will be delivered to decompressed_headers_.
   size_t bytes_consumed = session_->decompressor()->DecompressData(
       StringPiece(data, data_len), this);
   DCHECK_NE(0u, bytes_consumed);
   if (bytes_consumed > data_len) {
     DCHECK(false) << "DecompressData returned illegal value";
@@ skipping 94 matching lines @@
   DCHECK(!decompression_failed_);
   decompression_failed_ = true;
   session_->connection()->SendConnectionClose(QUIC_DECOMPRESSION_FAILURE);
 }
 
 
 void ReliableQuicStream::CloseWriteSide() {
   if (write_side_closed_) {
     return;
   }
-  DLOG(INFO) << "Done writing to stream " << id();
+  DLOG(INFO) << ENDPOINT << "Done writing to stream " << id();
 
   write_side_closed_ = true;
   if (read_side_closed_) {
-    DLOG(INFO) << "Closing stream: " << id();
+    DLOG(INFO) << ENDPOINT << "Closing stream: " << id();
     session_->CloseStream(id());
   }
 }
 
 bool ReliableQuicStream::HasBufferedData() {
   return !queued_data_.empty();
 }
 
 void ReliableQuicStream::OnClose() {
   CloseReadSide();
@@ skipping 32 matching lines @@
   if (data_len > 0 && headers_id_ == 0u) {
     // The headers ID has not yet been read.  Strip it from the beginning of
     // the data stream.
     total_bytes_parsed += StripUint32(
         data, data_len, &headers_id_and_priority_buffer_, &headers_id_);
   }
   return total_bytes_parsed;
 }
 
 }  // namespace net